home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Toolbox / Visual Basic Toolbox (P.I.E.)(1996).ISO / internet / weblibev / maindlg.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-10-30  |  63.5 KB  |  2,434 lines
  1. // maindlg.cpp : implementation file
  2. //
  3.  
  4. #include "stdafx.h"
  5. #include <fstream.h>
  6. #include <windowsx.h>
  7. #include "wltestc.h"
  8. #include "maindlg.h" 
  9. #include "wlapidlg.h"
  10.  
  11. #ifdef _DEBUG
  12. #undef THIS_FILE
  13. static char BASED_CODE THIS_FILE[] = __FILE__;
  14. #endif
  15.  
  16. #define ID_SYSMENU_LOG            0x80
  17.  
  18. #define WM_APP_APIDLGDESTROY    (WM_USER + 5000)
  19.  
  20. extern CWLTestApp NEAR theApp;
  21.  
  22. /////////////////////////////////////////////////////////////////////////////
  23. // CMainDlg dialog
  24.  
  25. BEGIN_MESSAGE_MAP(CMainDlg, CDialog)
  26.     //{{AFX_MSG_MAP(CMainDlg)
  27.     ON_WM_SYSCOMMAND()
  28.     ON_BN_CLICKED(IDC_BROWSER, OnBrowserAPI)
  29.     ON_BN_CLICKED(IDC_HTML, OnHtmlAPI)
  30.     ON_BN_CLICKED(IDC_TOOLBAR, OnToolbarAPI)
  31.     ON_BN_CLICKED(IDC_UTIL, OnUtilAPI)
  32.     ON_BN_CLICKED(IDC_GO_BTN, OnGoBtn)
  33.     ON_LBN_DBLCLK(IDC_LISTAPI, OnDblclkListapi)
  34.     ON_LBN_SELCHANGE(IDC_LISTAPI, OnSelchangeListapi)
  35.     ON_BN_CLICKED(IDC_NOTIFY_BTN, OnNotifyBtn)
  36.     ON_BN_CLICKED(IDC_STATUS_BTN, OnStatusBtn) 
  37.     ON_UPDATE_COMMAND_UI(IDC_NOTIFY_BTN, OnNotifyUpdateCmdUI)
  38.     ON_UPDATE_COMMAND_UI(IDC_STATUS_BTN, OnStatusUpdateCmdUI)
  39.     ON_MESSAGE(WM_WEBLIB_NOTIFY, OnApiNotification)
  40.     ON_MESSAGE(WM_WEBLIB_ENUMPARSETREE, OnEnumParseTree)
  41.     ON_MESSAGE(WM_WEBLIB_ENUMFINDTEXT, OnEnumFindText)
  42.     ON_MESSAGE(WM_WEBLIB_ENUMFINDSPEC, OnEnumFindSpecial)
  43.     ON_MESSAGE(WM_WEBLIB_ENUMFINDCOMM, OnEnumFindComment)
  44.     ON_MESSAGE(WM_WEBLIB_ENUMFINDTAGTYPE, OnEnumFindTagType)
  45.     ON_MESSAGE(WM_WEBLIB_ENUMFINDTAGNAME, OnEnumFindTagName)
  46.     ON_MESSAGE(WM_WEBLIB_ENUMFINDTAGATTR, OnEnumFindTagAttr) 
  47.     ON_MESSAGE(WM_APP_APIDLGDESTROY, OnApiDlgDestroy) 
  48.     ON_WM_DESTROY()
  49.     //}}AFX_MSG_MAP
  50. END_MESSAGE_MAP()
  51.  
  52. CMainDlg::CMainDlg(CWnd* pParent /*=NULL*/) : CDialog(CMainDlg::IDD, pParent)
  53. {
  54.     //{{AFX_DATA_INIT(CMainDlg)
  55.     //}}AFX_DATA_INIT
  56.     
  57.     m_bLogging = AfxGetApp()->GetProfileInt("OPTIONS","LOGGING",FALSE);
  58.     m_strLogFile = AfxGetApp()->GetProfileString("OPTIONS","LOGFILE");
  59.     
  60.     m_hBrowser = NULL;
  61.     m_hToolbar = NULL;
  62.     m_hParse = NULL;
  63.     m_hFormData = NULL;
  64.     
  65.     m_hFont = NULL;
  66.     m_hElement = NULL;
  67.     m_hTagAttr = NULL;
  68.     
  69.     m_staRegURLEcho = FALSE;
  70.     m_pnfyArray = NULL;  
  71.     
  72.     // Initialize WEBLIB dynamic link library.
  73.     
  74.     if (!WLStartup())                                            
  75.         Error(IDS_ERR_WLAPI,"WLStartup"); 
  76. }
  77.  
  78. CMainDlg::~CMainDlg()
  79. {   
  80.     if (m_bLogging)
  81.         AfxGetApp()->WriteProfileString("OPTIONS","LOGFILE",m_strLogFile);
  82.     AfxGetApp()->WriteProfileInt("OPTIONS","LOGGING",m_bLogging);
  83.     
  84.     m_ListboxInfo.Detach();
  85.     m_ListboxAPI.Detach();
  86.     
  87.     if (m_hFont != NULL && m_hToolbar == NULL)
  88.         ::DeleteObject(m_hFont);
  89.     
  90.     // Detach from WEBLIB DLL.
  91.     
  92.     if (!WLCleanup())                                            
  93.         Error(IDS_ERR_WLAPI,"WLCleanup"); 
  94. }
  95.  
  96. void CMainDlg::DoDataExchange(CDataExchange* pDX)
  97. {
  98.     CDialog::DoDataExchange(pDX);
  99.     //{{AFX_DATA_MAP(CMainDlg)
  100.     //}}AFX_DATA_MAP
  101. }
  102.  
  103. BOOL CMainDlg::OnInitDialog()
  104. {
  105.     CDialog::OnInitDialog();
  106.     CenterWindow(CWnd::GetDesktopWindow());
  107.     
  108.     // Set WEBLIB default window for WLN_BROWSERSTART and WLN_BROWSEREXIT notifications.
  109.     
  110.     if (!WLSetDefaultNotify(m_hWnd,WM_WEBLIB_NOTIFY))                
  111.         Error(IDS_ERR_WLAPI,"WLSetDefaultNotify");
  112.         
  113.     // Tell DLL containing dialogs to notify us when DLL dialog is destroyed. 
  114.         
  115.     ApiDlgNotifyOnWindowDestroy(m_hWnd,WM_APP_APIDLGDESTROY);
  116.     
  117.     // Add Log... option to system menu.
  118.     
  119.     CMenu *pMenu = GetSystemMenu(FALSE);
  120.     ASSERT(pMenu != NULL);          
  121.     
  122.     CString strLogMenuText;
  123.     strLogMenuText.LoadString(IDS_LOG_MENUTEXT);
  124.     
  125.     pMenu->AppendMenu(MF_SEPARATOR);
  126.     pMenu->AppendMenu(MF_STRING,ID_SYSMENU_LOG,strLogMenuText);
  127.     
  128.     // Attach listbox class instances to controls (not very OO-like, oh well!).
  129.     
  130.     m_ListboxInfo.Attach(GetDlgItem(IDC_LISTINFO)->m_hWnd);
  131.     m_ListboxAPI.Attach(GetDlgItem(IDC_LISTAPI)->m_hWnd);
  132.     
  133.     CRect rcClient;                                        // allow horz scrolling
  134.     m_ListboxInfo.GetClientRect(rcClient);
  135.     m_ListboxInfo.SetHorizontalExtent(rcClient.Width() * 3);
  136.     
  137.     GetDlgItem(IDC_CANCELTRX_BTN)->ShowWindow(SW_HIDE);    // no trx to cancel, hide button 
  138.     
  139.     // By default, check browser API calls.
  140.     
  141.     ((CButton *) GetDlgItem(IDC_BROWSER))->SetCheck(TRUE);
  142.     OnBrowserAPI();
  143.     
  144.     return TRUE;                  // return TRUE  unless you set the focus to a control
  145. }
  146.     
  147. void CMainDlg::OnCancel()
  148. {   
  149.     GetSystemMenu(TRUE);        // restore standard system menu
  150.     CDialog::OnCancel();
  151. }
  152.  
  153. LRESULT CMainDlg::WindowProc(UINT message,WPARAM wParam,LPARAM lParam)
  154. {
  155.     LRESULT lResult = CDialog::WindowProc(message,wParam,lParam);
  156.     
  157.     if (message == WM_COMMAND)
  158.         UpdateDialogControls(this,FALSE);
  159.     return lResult;
  160. }
  161.  
  162. void CMainDlg::OnSysCommand(UINT nID, LPARAM lParam)
  163. {
  164.     if ((nID & 0xFFF0) == ID_SYSMENU_LOG)                 
  165.     {
  166.         (void) ApiDlgLogging(m_strLogFile.GetBufferSetLength(_MAX_PATH),
  167.             _MAX_PATH,&m_bLogging);
  168.         m_strLogFile.ReleaseBuffer();
  169.     }
  170.     else
  171.         CDialog::OnSysCommand(nID,lParam);
  172. }
  173.  
  174. void CMainDlg::OnDestroy()
  175. {
  176.     if (m_hBrowser != NULL)
  177.         WLDisconnectBrowser(m_hBrowser,TRUE);    
  178.     if (m_hToolbar != NULL)
  179.         WLDeleteToolbar(m_hToolbar);
  180.     if (m_hParse != NULL)
  181.         WLHtmlEndParse(m_hParse);
  182.     
  183.     CDialog::OnDestroy();
  184. }
  185.  
  186. ///////////////////////////////////////////////////////////////////////////// 
  187. // When an API radio button is clicked, tailor dialog to the particular API.
  188.  
  189. void CMainDlg::OnBrowserAPI()
  190. {
  191.     CString strGoBtn;
  192.     strGoBtn.LoadString(m_hBrowser == NULL ? IDS_BTN_CONNECT : IDS_BTN_DISCONNECT);
  193.     
  194.     GetDlgItem(IDC_GO_BTN)->SetWindowText(strGoBtn);
  195.     GetDlgItem(IDC_GO_BTN)->EnableWindow(TRUE);    
  196.     GetDlgItem(IDC_STATUS_BTN)->EnableWindow(m_hBrowser != NULL);    
  197.     GetDlgItem(IDC_NOTIFY_BTN)->EnableWindow(m_hBrowser != NULL);    
  198.     
  199.     CString strApiStatic;
  200.     strApiStatic.LoadString(IDS_API_BROWSER);
  201.     GetDlgItem(IDC_API_STATIC)->SetWindowText(strApiStatic);
  202.     
  203.     m_ListboxInfo.ResetContent();
  204.     m_ListboxAPI.ResetContent();
  205.     GetDlgItem(IDC_INFO_STATIC)->SetWindowText("");
  206.     
  207.     if (m_hBrowser != NULL)
  208.     {
  209.         for (int nIdx=0;theApp.m_pszBrowserAPIs[nIdx] != NULL;nIdx++)
  210.             m_ListboxAPI.AddString(theApp.m_pszBrowserAPIs[nIdx]);
  211.         m_ListboxAPI.SetCurSel(0);
  212.     }
  213. }
  214.  
  215. void CMainDlg::OnToolbarAPI()
  216. {   
  217.     CString strGoBtn;
  218.     strGoBtn.LoadString(m_hToolbar == NULL ? IDS_BTN_CREATE : IDS_BTN_DELETE);
  219.     
  220.     GetDlgItem(IDC_GO_BTN)->SetWindowText(strGoBtn);
  221.     GetDlgItem(IDC_GO_BTN)->EnableWindow(TRUE);    
  222.     GetDlgItem(IDC_STATUS_BTN)->EnableWindow(m_hToolbar != NULL);    
  223.     GetDlgItem(IDC_NOTIFY_BTN)->EnableWindow(m_hToolbar != NULL);    
  224.     
  225.     CString strApiStatic;
  226.     strApiStatic.LoadString(IDS_API_TOOLBAR);
  227.     GetDlgItem(IDC_API_STATIC)->SetWindowText(strApiStatic);
  228.     
  229.     m_ListboxInfo.ResetContent();
  230.     m_ListboxAPI.ResetContent();
  231.     GetDlgItem(IDC_INFO_STATIC)->SetWindowText("");
  232.     
  233.     if (m_hToolbar != NULL)
  234.     {       
  235.         for (int nIdx=0;theApp.m_pszToolbarAPIs[nIdx] != NULL;nIdx++)
  236.             m_ListboxAPI.AddString(theApp.m_pszToolbarAPIs[nIdx]);
  237.         m_ListboxAPI.SetCurSel(0);
  238.     }
  239. }   
  240.  
  241. void CMainDlg::OnHtmlAPI()
  242. {   
  243.     CString strGoBtn;
  244.     strGoBtn.LoadString(m_hParse == NULL ? IDS_BTN_PARSE : IDS_BTN_ENDPARSE);
  245.     
  246.     GetDlgItem(IDC_GO_BTN)->SetWindowText(strGoBtn);
  247.     GetDlgItem(IDC_GO_BTN)->EnableWindow(TRUE);    
  248.     GetDlgItem(IDC_STATUS_BTN)->EnableWindow(FALSE);    
  249.     GetDlgItem(IDC_NOTIFY_BTN)->EnableWindow(m_hParse != NULL);    
  250.     
  251.     CString strApiStatic;
  252.     strApiStatic.LoadString(IDS_API_HTML);
  253.     GetDlgItem(IDC_API_STATIC)->SetWindowText(strApiStatic);
  254.     
  255.     m_ListboxInfo.ResetContent();
  256.     m_ListboxAPI.ResetContent();
  257.     GetDlgItem(IDC_INFO_STATIC)->SetWindowText("");
  258.     
  259.     if (m_hParse != NULL)
  260.     {       
  261.         for (int nIdx=0;theApp.m_pszHtmlAPIs[nIdx] != NULL;nIdx++)
  262.             m_ListboxAPI.AddString(theApp.m_pszHtmlAPIs[nIdx]);
  263.         m_ListboxAPI.SetCurSel(0);
  264.     }
  265. }
  266.  
  267. void CMainDlg::OnUtilAPI()
  268. {
  269.     CString strGoBtn;
  270.     strGoBtn.LoadString(IDS_BTN_ACCESSDATA);
  271.     
  272.     GetDlgItem(IDC_GO_BTN)->SetWindowText(strGoBtn);
  273.     GetDlgItem(IDC_GO_BTN)->EnableWindow(m_hFormData != NULL );    
  274.     GetDlgItem(IDC_STATUS_BTN)->EnableWindow(FALSE);    
  275.     GetDlgItem(IDC_NOTIFY_BTN)->EnableWindow(FALSE);   
  276.     
  277.     CString strApiStatic;
  278.     strApiStatic.LoadString(IDS_API_UTIL);
  279.     GetDlgItem(IDC_API_STATIC)->SetWindowText(strApiStatic);
  280.     
  281.     m_ListboxInfo.ResetContent();
  282.     m_ListboxAPI.ResetContent();        
  283.     GetDlgItem(IDC_INFO_STATIC)->SetWindowText("");
  284.     
  285.     for (int nIdx=0;theApp.m_pszUtilAPIs[nIdx] != NULL;nIdx++)
  286.         m_ListboxAPI.AddString(theApp.m_pszUtilAPIs[nIdx]);
  287.     m_ListboxAPI.SetCurSel(0);
  288. }
  289.  
  290. ///////////////////////////////////////////////////////////////////////////// 
  291. // On click of Go button, create or remove handle to browser, toolbar, parse
  292. // tree or form data. Once we have a valid handle, the API calls become available.
  293.  
  294. void CMainDlg::OnGoBtn()
  295. {
  296.     CDisableDialog disable(this);
  297.                               // for below to work, ordinal values of IDs better be correct!
  298.     switch (GetCheckedRadioButton(IDC_BROWSER,IDC_UTIL))
  299.     {
  300.         case IDC_BROWSER:
  301.             if (m_hBrowser == NULL)
  302.                 ConnectBrowserAPI();
  303.             else
  304.                 DisconnectBrowserAPI();
  305.             break;
  306.         
  307.         case IDC_TOOLBAR:
  308.             if (m_hToolbar == NULL)
  309.                 CreateToolbarAPI();
  310.             else
  311.                 DeleteToolbarAPI();
  312.             break;
  313.         
  314.         case IDC_HTML:
  315.             if (m_hParse == NULL)
  316.                 HtmlParseAPI();
  317.             else               
  318.                 HtmlEndParseAPI();
  319.             break;
  320.         
  321.         case IDC_UTIL: 
  322.             AccessFormDataAPI();
  323.             break;
  324.     }
  325. }
  326.  
  327. void CMainDlg::OnDblclkListapi()
  328. {
  329.     CDisableDialog disable(this);   
  330.     int nSelAPI = m_ListboxAPI.GetCurSel();
  331.     
  332.     switch (GetCheckedRadioButton(IDC_BROWSER,IDC_UTIL))
  333.     {
  334.         case IDC_BROWSER:
  335.             switch (nSelAPI)
  336.             { 
  337.                 case WLAPI_GetWindowInfo:
  338.                     GetWindowInfoAPI();
  339.                     break;
  340.                     
  341.                 case WLAPI_ListWindows:
  342.                     ListWindowsAPI();
  343.                     break;
  344.                     
  345.                 case WLAPI_ActivateWindow:
  346.                     ActivateWindowAPI();
  347.                     break;
  348.                     
  349.                 case WLAPI_CloseWindow:
  350.                     CloseWindowAPI();
  351.                     break;
  352.                     
  353.                 case WLAPI_SetWindowPos:
  354.                     SetWindowPosAPI();
  355.                     break;
  356.                     
  357.                 case WLAPI_ShowWindow:
  358.                     ShowWindowAPI();
  359.                     break;
  360.                     
  361.                 case WLAPI_ShowFile:
  362.                     ShowFileAPI();
  363.                     break;
  364.                     
  365.                 case WLAPI_OpenURL:
  366.                     OpenURLAPI();
  367.                     break;
  368.                     
  369.                 case WLAPI_SaveURL:
  370.                     SaveURLAPI();
  371.                     break;
  372.                     
  373.                 case WLAPI_PostFormData:
  374.                     PostFormDataAPI();
  375.                     break;
  376.                     
  377.                 case WLAPI_SaveFormData:
  378.                     SaveFormDataAPI();
  379.                        break;
  380.                        
  381.                 case WLAPI_RegisterProtocol:
  382.                     RegisterProtocolAPI();
  383.                     break;
  384.                     
  385.                 case WLAPI_UnregisterProtocol:
  386.                     UnregisterProtocolAPI();
  387.                     break;
  388.                     
  389.                 case WLAPI_RegisterURLEcho:
  390.                     RegisterURLEchoAPI();
  391.                     break;
  392.                     
  393.                 case WLAPI_UnregisterURLEcho:
  394.                         UnregisterURLEchoAPI();
  395.                     break;
  396.                     
  397.                 case WLAPI_RegisterViewer:
  398.                     RegisterViewerAPI();
  399.                     break;
  400.                     
  401.                 case WLAPI_UnregisterViewer:
  402.                     UnregisterViewerAPI();
  403.                     break;
  404.                     
  405.                 case WLAPI_RegisterWindowChange:
  406.                     RegisterWindowChangeAPI();
  407.                     break;
  408.                     
  409.                 case WLAPI_UnregisterWindowChange:
  410.                     UnregisterWindowChangeAPI();
  411.                     break;
  412.                     
  413.                 case WLAPI_ParseAnchor:
  414.                     ParseAnchorAPI();
  415.                     break;
  416.                     
  417.                 case WLAPI_GetVersion:
  418.                     GetVersionAPI();
  419.                     break;
  420.                     
  421.                 case WLAPI_QueryURLFile:
  422.                     QueryURLFileAPI();
  423.                     break;
  424.                     
  425.                 case WLAPI_SetNotifyMethod:
  426.                     SetNotifyMethodAPI();
  427.                     break;
  428.                     
  429.                    default:
  430.                       ::MessageBeep(-1);
  431.                       break;
  432.             }
  433.             break;
  434.         
  435.         case IDC_TOOLBAR:
  436.             switch (nSelAPI)
  437.             { 
  438.                 case WLAPI_IsToolbarActive:
  439.                     IsToolbarActiveAPI();
  440.                     break;
  441.                     
  442.                 case WLAPI_SetActiveToolbar:
  443.                     SetActiveToolbarAPI();
  444.                     break;
  445.                     
  446.                 case WLAPI_AddToolbarButton:
  447.                     AddToolbarButtonAPI();
  448.                     break;
  449.                     
  450.                 case WLAPI_RemoveToolbarButton:
  451.                     RemoveToolbarButtonAPI();
  452.                     break;
  453.                     
  454.                 case WLAPI_IsToolbarButtonVisible:
  455.                     IsToolbarButtonVisibleAPI();
  456.                     break;
  457.                     
  458.                 case WLAPI_ShowToolbarButton:
  459.                     ShowToolbarButtonAPI();
  460.                     break;
  461.                     
  462.                 case WLAPI_EnableToolbarButton:
  463.                     EnableToolbarButtonAPI();
  464.                     break;
  465.                     
  466.                 case WLAPI_IsToolbarButtonEnabled:
  467.                     IsToolbarButtonEnabledAPI();
  468.                     break;
  469.                     
  470.                 case WLAPI_GetToolbarText:
  471.                     GetToolbarTextAPI();
  472.                     break;
  473.                     
  474.                 case WLAPI_SetToolbarText:
  475.                     SetToolbarTextAPI();
  476.                     break;
  477.                                     
  478.                 case WLAPI_GetToolbarFont:
  479.                     GetToolbarFontAPI();
  480.                     break;
  481.                     
  482.                 case WLAPI_SetToolbarFont:
  483.                     SetToolbarFontAPI();
  484.                     break;
  485.                     
  486.                 case WLAPI_GetToolbarBkgnd:
  487.                     GetToolbarBkgndAPI();
  488.                     break;
  489.                     
  490.                 case WLAPI_SetToolbarBkgnd:
  491.                     SetToolbarBkgndAPI();
  492.                     break;
  493.                     
  494.                 case WLAPI_GetToolbarTextColor: 
  495.                     GetToolbarTextColorAPI();
  496.                     break;
  497.                     
  498.                 case WLAPI_SetToolbarTextColor: 
  499.                     SetToolbarTextColorAPI();
  500.                     break;
  501.                             
  502.                   default:
  503.                       ::MessageBeep(-1);
  504.                       break;
  505.             }
  506.             break;
  507.         
  508.         case IDC_HTML:
  509.             switch (nSelAPI)
  510.             {
  511.                 case WLAPI_HtmlEnumParseTree:
  512.                        HtmlEnumParseTreeAPI();
  513.                     break;
  514.                     
  515.                 case WLAPI_HtmlGetChild:
  516.                     HtmlGetChildAPI();
  517.                     break;
  518.                     
  519.                 case WLAPI_HtmlGetParent:
  520.                     HtmlGetParentAPI();
  521.                     break;
  522.                     
  523.                 case WLAPI_HtmlGetSibling:
  524.                     HtmlGetSiblingAPI();
  525.                     break;
  526.                     
  527.                 case WLAPI_HtmlGetElementType:
  528.                     HtmlGetElementTypeAPI();
  529.                     break;
  530.                     
  531.                 case WLAPI_HtmlGetElementText: 
  532.                     HtmlGetElementTextAPI();
  533.                     break;
  534.                     
  535.                 case WLAPI_HtmlGetTextAttr: 
  536.                     HtmlGetTextAttrAPI();
  537.                     break;
  538.                     
  539.                 case WLAPI_HtmlGetTagName: 
  540.                     HtmlGetTagNameAPI();
  541.                     break;
  542.                     
  543.                 case WLAPI_HtmlGetTagType:
  544.                     HtmlGetTagTypeAPI();
  545.                     break;
  546.                     
  547.                 case WLAPI_HtmlGetTagAttr:
  548.                     HtmlGetTagAttrAPI();
  549.                     break;
  550.                     
  551.                 case WLAPI_HtmlExtractTagAttr:
  552.                     HtmlExtractTagAttrAPI();
  553.                     break;
  554.                     
  555.                 case WLAPI_HtmlFindText:
  556.                     HtmlFindTextAPI();
  557.                     break;
  558.                     
  559.                 case WLAPI_HtmlFindSpecial:
  560.                     HtmlFindSpecialAPI();
  561.                     break;
  562.                     
  563.                 case WLAPI_HtmlFindComment:
  564.                     HtmlFindCommentAPI();
  565.                     break;
  566.                     
  567.                 case WLAPI_HtmlFindTagType:
  568.                     HtmlFindTagTypeAPI();
  569.                     break;
  570.                     
  571.                 case WLAPI_HtmlFindTagName:
  572.                     HtmlFindTagNameAPI();
  573.                     break;
  574.                     
  575.                 case WLAPI_HtmlFindTagAttr:
  576.                     HtmlFindTagAttrAPI();
  577.                     break;
  578.                     
  579.                 case WLAPI_HtmlEnumFindText:
  580.                     HtmlEnumFindTextAPI();
  581.                     break;
  582.                     
  583.                 case WLAPI_HtmlEnumFindSpecial: 
  584.                     HtmlEnumFindSpecialAPI();
  585.                     break;
  586.                     
  587.                 case WLAPI_HtmlEnumFindComment:
  588.                     HtmlEnumFindCommentAPI();
  589.                     break;
  590.                     
  591.                 case WLAPI_HtmlEnumFindTagType:
  592.                     HtmlEnumFindTagTypeAPI();
  593.                     break;
  594.                     
  595.                 case WLAPI_HtmlEnumFindTagName: 
  596.                     HtmlEnumFindTagNameAPI();
  597.                     break;
  598.                     
  599.                 case WLAPI_HtmlEnumFindTagAttr:
  600.                     HtmlEnumFindTagAttrAPI();
  601.                       break;
  602.                       
  603.                   default:
  604.                       ::MessageBeep(-1);
  605.                       break;
  606.             }
  607.             break;
  608.         
  609.         case IDC_UTIL: 
  610.             switch (nSelAPI)
  611.             {
  612.                 case WLAPI_AppendFormData:  
  613.                     AppendFormDataAPI();
  614.                      break;
  615.                      
  616.                 case WLAPI_GetFormDataLength:
  617.                        GetFormDataLengthAPI();
  618.                      break;
  619.                      
  620.                 case WLAPI_ParseAbsoluteURL:
  621.                     ParseAbsoluteURLAPI();
  622.                      break;
  623.                     
  624.                   default:
  625.                       ::MessageBeep(-1);
  626.                       break;
  627.             }
  628.             break;
  629.             
  630.         default:    
  631.             ::MessageBeep(-1);
  632.               break;
  633.     }
  634. }
  635.  
  636. void CMainDlg::OnSelchangeListapi()
  637. {   
  638.     m_ListboxInfo.ResetContent(); 
  639.     GetDlgItem(IDC_INFO_STATIC)->SetWindowText("");
  640. }
  641.  
  642. void CMainDlg::OnNotifyBtn()
  643. {           
  644.     int nSelAPI = m_ListboxAPI.GetCurSel();
  645.  
  646.     CString strInfo;
  647.     strInfo.LoadString(IDS_NOTIFY_TITLE);
  648.     
  649.     CString strText; 
  650.     
  651.     if (GetCheckedRadioButton(IDC_BROWSER,IDC_UTIL) == IDC_TOOLBAR)
  652.         strText.LoadString(IDS_NOTIFY_TOOLBAR);
  653.     else
  654.         m_ListboxAPI.GetText(nSelAPI,strText);
  655.        
  656.     strInfo += strText;
  657.     GetDlgItem(IDC_INFO_STATIC)->SetWindowText(strInfo);
  658.     
  659.     switch (GetCheckedRadioButton(IDC_BROWSER,IDC_UTIL))
  660.     {                     
  661.         case IDC_BROWSER:                 
  662.         {
  663.             CStringArray *pnfyArray = NULL;    
  664.             
  665.             if (nSelAPI == WLAPI_ShowFile)
  666.                 pnfyArray = &m_nfyShowFile;
  667.             else if (nSelAPI == WLAPI_OpenURL)
  668.                 pnfyArray = &m_nfyOpenURL;
  669.             else if (nSelAPI == WLAPI_SaveURL)
  670.                 pnfyArray = &m_nfySaveURL;
  671.             else if (nSelAPI == WLAPI_PostFormData)
  672.                 pnfyArray = &m_nfyPostFormData;
  673.             else if (nSelAPI == WLAPI_SaveFormData)
  674.                 pnfyArray = &m_nfySaveFormData;
  675.             else if (nSelAPI == WLAPI_RegisterProtocol)
  676.                 pnfyArray = &m_nfyRegProtocol;
  677.             else if (nSelAPI == WLAPI_RegisterURLEcho)
  678.                 pnfyArray = &m_nfyRegURLEcho;
  679.             else if (nSelAPI == WLAPI_RegisterViewer)
  680.                 pnfyArray = &m_nfyRegViewer;
  681.             else if (nSelAPI == WLAPI_RegisterWindowChange)
  682.                 pnfyArray = &m_nfyRegWindowChange;
  683.                 
  684.             if (pnfyArray != NULL)
  685.                 FillInfoListbox(*pnfyArray);
  686.             break;
  687.         }
  688.         
  689.         case IDC_TOOLBAR:
  690.             FillInfoListbox(m_nfyToolbar);
  691.             break;
  692.         
  693.         case IDC_HTML:    
  694.         {
  695.             CStringArray *pnfyArray = NULL;    
  696.                 
  697.             if (nSelAPI == WLAPI_HtmlEnumParseTree)
  698.                 pnfyArray = &m_nfyEnumParseTree;
  699.             else if (nSelAPI == WLAPI_HtmlEnumFindText)
  700.                 pnfyArray = &m_nfyEnumFindText;
  701.             else if (nSelAPI == WLAPI_HtmlEnumFindSpecial)
  702.                 pnfyArray = &m_nfyEnumFindSpecial;
  703.             else if (nSelAPI == WLAPI_HtmlEnumFindComment)
  704.                 pnfyArray = &m_nfyEnumFindComment;            
  705.             else if (nSelAPI == WLAPI_HtmlEnumFindTagType)
  706.                 pnfyArray = &m_nfyEnumFindTagType;    
  707.             else if (nSelAPI == WLAPI_HtmlEnumFindTagName)
  708.                 pnfyArray = &m_nfyEnumFindTagName;    
  709.             else if (nSelAPI == WLAPI_HtmlEnumFindTagAttr)
  710.                 pnfyArray = &m_nfyEnumFindTagAttr;
  711.             
  712.             if (pnfyArray != NULL)
  713.                 FillInfoListbox(*pnfyArray);
  714.             break;
  715.         }
  716.         
  717.         case IDC_UTIL: 
  718.             break;
  719.     }    
  720. }
  721.  
  722. void CMainDlg::OnStatusBtn()
  723. {
  724.     int nSelAPI = m_ListboxAPI.GetCurSel();   
  725.     
  726.     CString strInfo;
  727.     strInfo.LoadString(IDS_STATUS_TITLE);
  728.     
  729.     CString strText; 
  730.     
  731.     if (GetCheckedRadioButton(IDC_BROWSER,IDC_UTIL) == IDC_TOOLBAR)
  732.         strText.LoadString(IDS_STATUS_TOOLBAR);
  733.     else
  734.         m_ListboxAPI.GetText(nSelAPI,strText);
  735.        
  736.     strInfo += strText;
  737.     GetDlgItem(IDC_INFO_STATIC)->SetWindowText(strInfo);
  738.                                                            
  739.     switch (GetCheckedRadioButton(IDC_BROWSER,IDC_UTIL))
  740.     {                     
  741.         case IDC_BROWSER:                 
  742.         {
  743.             CStringArray staArray,*pstaArray = NULL;    
  744.             char szBuf[16];
  745.             
  746.             if (nSelAPI == WLAPI_RegisterProtocol)
  747.                 pstaArray = &m_staRegProtocol;
  748.             else if (nSelAPI == WLAPI_RegisterViewer)
  749.                 pstaArray = &m_staRegViewer;
  750.             else if (nSelAPI == WLAPI_RegisterURLEcho && m_staRegURLEcho)
  751.             {   
  752.                 CString strStatus;                     
  753.                 strStatus.LoadString(IDS_STAT_URLECHO);
  754.                 
  755.                 staArray.Add(strStatus);
  756.                 pstaArray = &staArray;                
  757.             }
  758.             else if (nSelAPI == WLAPI_RegisterWindowChange)
  759.             {
  760.                 for (int nIdx=0;nIdx < m_staRegWindowChange.GetSize();nIdx++)
  761.                     staArray.Add(CString(ltoa((long) m_staRegWindowChange[nIdx],szBuf,10)));
  762.                 pstaArray = &staArray;    
  763.             }
  764.                 
  765.             if (pstaArray != NULL)
  766.                 FillInfoListbox(*pstaArray);
  767.             break;
  768.         }
  769.         
  770.         case IDC_TOOLBAR:
  771.         {                           
  772.             CStringArray staArray;
  773.             char szID[16];            
  774.             
  775.             for (int nIdx=0;nIdx < m_staToolbar.GetSize();nIdx++)
  776.                 staArray.Add(CString(itoa((int) m_staToolbar[nIdx],szID,10)));
  777.             FillInfoListbox(staArray);
  778.             break;
  779.         }
  780.         
  781.         case IDC_HTML:    
  782.             break;
  783.         
  784.         case IDC_UTIL: 
  785.             break;
  786.     }    
  787. }
  788.  
  789. void CMainDlg::OnNotifyUpdateCmdUI(CCmdUI* pCmdUI)
  790. {                       
  791.     int nSelAPI = m_ListboxAPI.GetCurSel();
  792.     BOOL bEnable = TRUE;
  793.     
  794.     switch (GetCheckedRadioButton(IDC_BROWSER,IDC_UTIL))
  795.     {
  796.         case IDC_BROWSER:
  797.             if (bEnable = m_hBrowser != NULL)
  798.                 bEnable = nSelAPI == WLAPI_ShowFile ||
  799.                           nSelAPI == WLAPI_OpenURL ||
  800.                           nSelAPI == WLAPI_SaveURL ||
  801.                           nSelAPI == WLAPI_PostFormData ||
  802.                           nSelAPI == WLAPI_SaveFormData ||
  803.                           nSelAPI == WLAPI_RegisterProtocol ||
  804.                           nSelAPI == WLAPI_RegisterURLEcho ||
  805.                           nSelAPI == WLAPI_RegisterViewer ||
  806.                           nSelAPI == WLAPI_RegisterWindowChange;
  807.             break;
  808.         
  809.         case IDC_TOOLBAR:
  810.             bEnable = m_hToolbar != NULL;
  811.             break;
  812.         
  813.         case IDC_HTML:
  814.             if (bEnable = m_hParse != NULL)
  815.                 bEnable = nSelAPI == WLAPI_HtmlEnumParseTree ||
  816.                           nSelAPI == WLAPI_HtmlEnumFindText ||
  817.                           nSelAPI == WLAPI_HtmlEnumFindSpecial ||
  818.                           nSelAPI == WLAPI_HtmlEnumFindComment ||
  819.                           nSelAPI == WLAPI_HtmlEnumFindTagType ||
  820.                           nSelAPI == WLAPI_HtmlEnumFindTagName ||
  821.                           nSelAPI == WLAPI_HtmlEnumFindTagAttr;
  822.             break;
  823.         
  824.         case IDC_UTIL: 
  825.             bEnable = FALSE;
  826.             break;
  827.     }
  828.     pCmdUI->Enable(bEnable);
  829. }
  830.  
  831. void CMainDlg::OnStatusUpdateCmdUI(CCmdUI* pCmdUI)
  832. {   
  833.     int nSelAPI = m_ListboxAPI.GetCurSel();
  834.     BOOL bEnable = TRUE;
  835.     
  836.     switch (GetCheckedRadioButton(IDC_BROWSER,IDC_UTIL))
  837.     {
  838.         case IDC_BROWSER:
  839.             if (bEnable = m_hBrowser != NULL)
  840.                 bEnable = nSelAPI == WLAPI_RegisterProtocol ||
  841.                           nSelAPI == WLAPI_RegisterURLEcho ||
  842.                           nSelAPI == WLAPI_RegisterViewer ||
  843.                           nSelAPI == WLAPI_RegisterWindowChange;
  844.             break;
  845.         
  846.         case IDC_TOOLBAR:
  847.             bEnable = m_hToolbar != NULL;
  848.             break;
  849.         
  850.         case IDC_HTML:
  851.             bEnable = FALSE;
  852.             break;
  853.         
  854.         case IDC_UTIL: 
  855.             bEnable = FALSE;
  856.             break;
  857.     }
  858.     pCmdUI->Enable(bEnable);
  859. }
  860.  
  861. ///////////////////////////////////////////////////////////////////////////// 
  862. // Methods for each WEBLIB API.
  863.  
  864. void CMainDlg::ConnectBrowserAPI()
  865. {                            
  866.     BOOL bStart = TRUE,bSend = FALSE,bPost = TRUE;
  867.                     
  868.     if (ApiDlgConnectBrowser(&bStart,&bSend,&bPost))
  869.     {
  870.         WORD wOptions = (bStart ? WL_STARTBROWSER : 0) |
  871.                         (bSend  ? WL_SENDMESSAGE  : 0) |
  872.                         (bPost  ? WL_POSTMESSAGE  : 0);
  873.                                         
  874.         if ((m_hBrowser = WLConnectBrowser(wOptions)) == NULL)         
  875.             Error(IDS_ERR_WLAPI,"WLConnectBrowser"); 
  876.         else
  877.             ApiReturnValue("WLConnectBrowser");
  878.         OnBrowserAPI();
  879.     }
  880. }
  881.  
  882. void CMainDlg::DisconnectBrowserAPI()
  883. {  
  884.     BOOL bExit = TRUE;
  885.                  
  886.     if (ApiDlgDisconnectBrowser(&bExit))
  887.     {
  888.         m_nfyShowFile.RemoveAll();
  889.         m_nfyOpenURL.RemoveAll();
  890.         m_nfySaveURL.RemoveAll();
  891.         m_nfyPostFormData.RemoveAll();    
  892.         m_nfySaveFormData.RemoveAll();
  893.         m_nfyRegProtocol.RemoveAll();
  894.         m_nfyRegURLEcho.RemoveAll();
  895.         m_nfyRegViewer.RemoveAll();
  896.         m_nfyRegWindowChange.RemoveAll();
  897.     
  898.         if (WLDisconnectBrowser(m_hBrowser,bExit))                    
  899.         {   
  900.             ApiReturnValue("WLDisconnectBrowser");
  901.             m_hBrowser = NULL;
  902.             OnBrowserAPI();
  903.         }
  904.         else   
  905.             Error(IDS_ERR_WLAPI,"WLDisconnectBrowser"); 
  906.     }
  907. }
  908.         
  909. void CMainDlg::CreateToolbarAPI()
  910. {                            
  911.     char szMenu[64] = "";
  912.                 
  913.     if (ApiDlgCreateToolbar(szMenu,sizeof(szMenu)))
  914.     {
  915.         m_hToolbar = WLCreateToolbar(szMenu,m_hWnd,WM_WEBLIB_NOTIFY);
  916.         if (m_hToolbar == NULL)                                     
  917.             Error(IDS_ERR_WLAPI,"WLCreateToolbar"); 
  918.         else
  919.             ApiReturnValue("WLCreateToolbar");
  920.         OnToolbarAPI();
  921.     }
  922. }
  923.  
  924. void CMainDlg::DeleteToolbarAPI()
  925. {   
  926.     m_nfyToolbar.RemoveAll();
  927.     
  928.     if (WLDeleteToolbar(m_hToolbar))                                
  929.     {   
  930.         ApiReturnValue("WLDeleteToolbar");
  931.         m_hToolbar = NULL;
  932.         OnToolbarAPI();
  933.     }
  934.     else   
  935.         Error(IDS_ERR_WLAPI,"WLDeleteToolbar"); 
  936. }
  937.         
  938. void CMainDlg::HtmlParseAPI()
  939. {   
  940.     BOOL bAttr = FALSE,bClosing = FALSE;                         
  941.     char szFile[_MAX_PATH] = "",szBuf[MAX_HTMLBUF] = "";
  942.     char *pszBuf = szBuf; 
  943.     UINT cbBuf = sizeof(szBuf);
  944.                     
  945.     if (ApiDlgHtmlParse(szFile,sizeof(szFile),pszBuf,cbBuf,&bAttr,&bClosing))
  946.     { 
  947.         WORD wOptions = (bAttr ? WL_KEEPATTRIBUTETAG : 0) |
  948.                         (bClosing ? WL_KEEPCLOSINGTAG : 0);
  949.                                         
  950.         if (szFile[0])
  951.             m_hParse = WLHtmlParseFile(szFile,wOptions);            
  952.         else           
  953.             m_hParse = WLHtmlParseBuf(pszBuf,lstrlen(pszBuf),wOptions);
  954.                             
  955.         if (m_hParse == NULL) 
  956.             Error(IDS_ERR_WLAPI,szFile[0] ? "WLHtmlParseFile" : "WLHtmlParseBuf"); 
  957.         else 
  958.         {
  959.             ApiReturnValue(szFile[0] ? "WLHtmlParseFile" : "WLHtmlParseBuf");
  960.             m_hElement = WL_ROOTELEMENT;
  961.             m_hTagAttr = NULL;
  962.         }
  963.         OnHtmlAPI();
  964.     }
  965. }             
  966.  
  967. void CMainDlg::HtmlEndParseAPI()
  968. { 
  969.     m_nfyEnumParseTree.RemoveAll();
  970.     m_nfyEnumFindText.RemoveAll();
  971.     m_nfyEnumFindSpecial.RemoveAll();
  972.     m_nfyEnumFindComment.RemoveAll();
  973.     m_nfyEnumFindTagType.RemoveAll();
  974.     m_nfyEnumFindTagName.RemoveAll();
  975.     m_nfyEnumFindTagAttr.RemoveAll(); 
  976.     
  977.     if (WLHtmlEndParse(m_hParse))                                    
  978.     {   
  979.         ApiReturnValue("WLHtmlEndParse");
  980.         m_hParse = NULL;
  981.         m_hElement = NULL;
  982.         OnHtmlAPI();
  983.     }
  984.     else   
  985.         Error(IDS_ERR_WLAPI,"WLHtmlEndParse"); 
  986. }
  987.         
  988. void CMainDlg::AccessFormDataAPI()
  989. {   
  990.     ASSERT(m_hFormData != NULL);
  991.     UINT nDataLength = WLGetFormDataLength(m_hFormData);            
  992.             
  993.     if (nDataLength == 0)
  994.         Error(IDS_ERR_WLAPI,"WLGetFormDataLength"); 
  995.     else 
  996.     {   
  997.         nDataLength += sizeof('\0');
  998.         LPSTR lpszFormData = (LPSTR) GlobalAllocPtr(GHND,nDataLength);
  999.                 
  1000.         if (WLAccessFormData(m_hFormData,lpszFormData,nDataLength))
  1001.         {                                                           
  1002.             ApiDlgAccessFormData(lpszFormData);
  1003.             ApiReturnValue("WLAccessFormData");
  1004.         }
  1005.         else
  1006.             Error(IDS_ERR_WLAPI,"WLAccessFormData"); 
  1007.                 
  1008.         GlobalFreePtr(lpszFormData);
  1009.         m_hFormData = NULL;
  1010.         OnUtilAPI();
  1011.     }
  1012. }
  1013.  
  1014. void CMainDlg::GetWindowInfoAPI()
  1015. {   
  1016.     DWORD dwWindow = 0;
  1017.     char szURL[128] = "",szTitle[128] = "";
  1018.     
  1019.     if (ApiDlgGetWindowInfo(&dwWindow))                             
  1020.         if (WLGetWindowInfo(m_hBrowser,dwWindow,szURL,sizeof(szURL),szTitle,sizeof(szTitle)))
  1021.             ApiReturnValue("WLGetWindowInfo",szURL,szTitle);
  1022.         else
  1023.             Error(IDS_ERR_WLAPI,"WLGetWindowInfo"); 
  1024. }
  1025.  
  1026. void CMainDlg::ListWindowsAPI()
  1027. {
  1028.     BOOL bFirst = FALSE;  
  1029.                     
  1030.     if (ApiDlgListWindows(&bFirst))
  1031.     {
  1032.         DWORD dwWindow = WLListWindows(m_hBrowser,bFirst ? WL_FIRSTWINDOW : WL_NEXTWINDOW);
  1033.         char szWindow[16];                                             
  1034.         
  1035.         if (dwWindow == 0)
  1036.             Error(IDS_ERR_WLAPI,"WLListWindows"); 
  1037.         else                                       
  1038.             ApiReturnValue("WLListWindows",_ltoa((long) dwWindow,szWindow,10));
  1039.     }
  1040. }
  1041.  
  1042. void CMainDlg::ActivateWindowAPI()
  1043. {   
  1044.     DWORD dwWindow = 0;
  1045.     char szWindow[16];    
  1046.     
  1047.     if (ApiDlgActivateWindow(&dwWindow))
  1048.         if ((dwWindow = WLActivateWindow(m_hBrowser,dwWindow)))        
  1049.             ApiReturnValue("WLActivateWindow",_ltoa((long) dwWindow,szWindow,10));
  1050.         else
  1051.             Error(IDS_ERR_WLAPI,"WLActivateWindow"); 
  1052. }
  1053.  
  1054. void CMainDlg::CloseWindowAPI()
  1055. {   
  1056.     DWORD dwWindow = 0;
  1057.     
  1058.     if (ApiDlgCloseWindow(&dwWindow))
  1059.         if (WLCloseWindow(m_hBrowser,dwWindow))                        
  1060.             ApiReturnValue("WLCloseWindow");
  1061.         else
  1062.             Error(IDS_ERR_WLAPI,"WLCloseWindow"); 
  1063. }
  1064.  
  1065. void CMainDlg::SetWindowPosAPI()
  1066. {   
  1067.     DWORD dwWindow = 0,dwX = 0,dwY = 0,dwWidth = 0,dwHeight = 0;
  1068.     
  1069.     if (ApiDlgSetWindowPos(&dwWindow,&dwX,&dwY,&dwWidth,&dwHeight))
  1070.         if (WLSetWindowPos(m_hBrowser,dwWindow,dwX,dwY,dwWidth,dwHeight))    
  1071.             ApiReturnValue("WLSetWindowPos");                        
  1072.         else
  1073.             Error(IDS_ERR_WLAPI,"WLSetWindowPos"); 
  1074. }
  1075.  
  1076. void CMainDlg::ShowWindowAPI()
  1077. {   
  1078.     DWORD dwWindow = 0;
  1079.     UINT nShow = WL_NORMAL;
  1080.     
  1081.     if (ApiDlgShowWindow(&dwWindow,&nShow))
  1082.         if (WLShowWindow(m_hBrowser,dwWindow,nShow))                
  1083.             ApiReturnValue("WLShowWindow");
  1084.         else
  1085.             Error(IDS_ERR_WLAPI,"WLShowWindow"); 
  1086. }
  1087.  
  1088. void CMainDlg::ShowFileAPI()
  1089. {         
  1090.     BOOL bNotify = 0;
  1091.     DWORD dwWindow = 0;
  1092.     char szFile[128] = "",szMIME[64] = "",szURL[128] = "";
  1093.     
  1094.     if (ApiDlgShowFile(szFile,sizeof(szFile),szMIME,sizeof(szMIME),&bNotify,szURL,
  1095.         sizeof(szURL),&dwWindow))
  1096.     {
  1097.         (m_pnfyArray = &m_nfyShowFile)->RemoveAll();
  1098.      
  1099.         DWORD dwTrx = WLShowFile(m_hBrowser,szFile,szMIME,dwWindow,szURL,
  1100.             bNotify ? m_hWnd : WL_NONOTIFY,bNotify ? WM_WEBLIB_NOTIFY : 0);
  1101.         char szTrx[16];                                            
  1102.             
  1103.         if (dwTrx == 0)
  1104.             Error(IDS_ERR_WLAPI,"WLShowFile"); 
  1105.         else
  1106.             ApiReturnValue("WLShowFile",_ltoa((long) dwTrx,szTrx,10));
  1107.     }
  1108. }
  1109.  
  1110. void CMainDlg::OpenURLAPI()
  1111. {   
  1112.     BOOL bBackground = FALSE,bNoDocCache = FALSE,bNoImageCache = FALSE,bNotify = TRUE;
  1113.     DWORD dwWindow = 0;
  1114.     char szURL[128] = "";
  1115.  
  1116.     if (ApiDlgOpenURL(&bBackground,&bNoDocCache,&bNoImageCache,&bNotify,szURL,
  1117.         sizeof(szURL),&dwWindow))
  1118.     {    
  1119.         (m_pnfyArray = &m_nfyOpenURL)->RemoveAll();
  1120.     
  1121.         WORD wOptions = (bBackground ? WL_BACKGROUNDMODE : 0) |       
  1122.                         (bNoDocCache ? WL_NODOCUMENTCACHE : 0) |  
  1123.                         (bNoImageCache ? WL_NOIMAGECACHE : 0);
  1124.         char szTrx[16];
  1125.                         
  1126.         DWORD dwTrx = WLOpenURL(m_hBrowser,szURL,dwWindow,wOptions,        
  1127.             bNotify ? m_hWnd : WL_NONOTIFY,bNotify ? WM_WEBLIB_NOTIFY : 0);
  1128.             
  1129.         if (dwTrx == 0)
  1130.             Error(IDS_ERR_WLAPI,"WLOpenURL"); 
  1131.         else
  1132.             ApiReturnValue("WLOpenURL",_ltoa((long) dwTrx,szTrx,10));
  1133.     }
  1134. }
  1135.  
  1136. void CMainDlg::SaveURLAPI()
  1137. {       
  1138.     BOOL bBackground = FALSE,bNoDocCache = FALSE,bNoImageCache = FALSE,bNotify = TRUE;
  1139.     DWORD dwWindow = 0;
  1140.     char szURL[128] = "",szFile[128] = "";
  1141.  
  1142.     if (ApiDlgSaveURL(&bBackground,&bNoDocCache,&bNoImageCache,&bNotify,szURL,
  1143.         sizeof(szURL),szFile,sizeof(szFile),&dwWindow))
  1144.     {
  1145.         (m_pnfyArray = &m_nfySaveURL)->RemoveAll();
  1146.         
  1147.         WORD wOptions = (bBackground ? WL_BACKGROUNDMODE : 0) |       
  1148.                         (bNoDocCache ? WL_NODOCUMENTCACHE : 0) |  
  1149.                         (bNoImageCache ? WL_NOIMAGECACHE : 0);
  1150.         char szTrx[16];
  1151.                         
  1152.         DWORD dwTrx = WLSaveURL(m_hBrowser,szURL,szFile,dwWindow,wOptions,    
  1153.             bNotify ? m_hWnd : WL_NONOTIFY,bNotify ? WM_WEBLIB_NOTIFY : 0);
  1154.             
  1155.         if (dwTrx == 0)
  1156.             Error(IDS_ERR_WLAPI,"WLSaveURL"); 
  1157.         else
  1158.             ApiReturnValue("WLSaveURL",_ltoa((long) dwTrx,szTrx,10));
  1159.     }
  1160. }
  1161.  
  1162. void CMainDlg::PostFormDataAPI()
  1163. {   
  1164.     BOOL bNotify = TRUE;
  1165.     DWORD dwWindow = 0;
  1166.     char szFormData[MAX_FORMDATA] = "",szMIME[64] = "",szURL[128] = "";
  1167.  
  1168.     if (ApiDlgPostFormData(szFormData,sizeof(szFormData),szMIME,sizeof(szMIME),
  1169.         &bNotify,szURL,sizeof(szURL),&dwWindow))
  1170.     {
  1171.         (m_pnfyArray = &m_nfyPostFormData)->RemoveAll();       
  1172.         
  1173.         DWORD dwTrx = WLPostFormData(m_hBrowser,szURL,dwWindow,szFormData,    
  1174.             szMIME,bNotify ? m_hWnd : WL_NONOTIFY,bNotify ? WM_WEBLIB_NOTIFY : 0);
  1175.         char szTrx[16];
  1176.             
  1177.         if (dwTrx == 0)
  1178.             Error(IDS_ERR_WLAPI,"WLPostFormData"); 
  1179.         else
  1180.             ApiReturnValue("WLPostFormData",_ltoa((long) dwTrx,szTrx,10));
  1181.     }
  1182. }
  1183.  
  1184. void CMainDlg::SaveFormDataAPI()
  1185. {
  1186.     BOOL bNotify = TRUE;
  1187.     DWORD dwWindow = 0;
  1188.     char szFile[128] = "",szFormData[MAX_FORMDATA] = "",szMIME[64] = "",szURL[128] = "";
  1189.  
  1190.     if (ApiDlgSaveFormData(szFile,sizeof(szFile),szFormData,sizeof(szFormData),
  1191.         szMIME,sizeof(szMIME),&bNotify,szURL,sizeof(szURL),&dwWindow))
  1192.     {
  1193.         (m_pnfyArray = &m_nfySaveFormData)->RemoveAll();
  1194.     
  1195.         DWORD dwTrx = WLSaveFormData(m_hBrowser,szURL,szFile,dwWindow,    
  1196.             szFormData,szMIME,bNotify ? m_hWnd : WL_NONOTIFY,
  1197.                 bNotify ? WM_WEBLIB_NOTIFY : 0);
  1198.         char szTrx[16];
  1199.             
  1200.         if (dwTrx == 0)
  1201.             Error(IDS_ERR_WLAPI,"WLSaveFormData"); 
  1202.         else
  1203.             ApiReturnValue("WLSaveFormData",_ltoa((long) dwTrx,szTrx,10));
  1204.     }
  1205. }
  1206.  
  1207. void CMainDlg::RegisterProtocolAPI()
  1208. {
  1209.     char szProtocol[64] = "";
  1210.     
  1211.     if (ApiDlgRegisterProtocol(szProtocol,sizeof(szProtocol)))
  1212.     {
  1213.         if (WLRegisterProtocol(m_hBrowser,szProtocol,m_hWnd,WM_WEBLIB_NOTIFY))
  1214.         {
  1215.             m_staRegProtocol.Add(CString(szProtocol));
  1216.             ApiReturnValue("WLRegisterProtocol");
  1217.         }
  1218.         else
  1219.             Error(IDS_ERR_WLAPI,"WLRegisterProtocol"); 
  1220.     }
  1221. }
  1222.  
  1223. void CMainDlg::UnregisterProtocolAPI()
  1224. {
  1225.     char szProtocol[64] = "";
  1226.     
  1227.     if (ApiDlgUnregisterProtocol(szProtocol,sizeof(szProtocol)))
  1228.     {       
  1229.         RemoveFromStatusArray(m_staRegProtocol,CString(szProtocol));
  1230.         if (m_staRegProtocol.GetSize() == 0)
  1231.             m_nfyRegProtocol.RemoveAll();
  1232.         
  1233.         if (WLUnregisterProtocol(m_hBrowser,szProtocol,m_hWnd))
  1234.             ApiReturnValue("WLUnregisterProtocol");
  1235.         else
  1236.             Error(IDS_ERR_WLAPI,"WLUnregisterProtocol"); 
  1237.     }
  1238. }
  1239.  
  1240. void CMainDlg::RegisterURLEchoAPI()
  1241. {
  1242.     if (WLRegisterURLEcho(m_hBrowser,m_hWnd,WM_WEBLIB_NOTIFY))
  1243.     {
  1244.         m_staRegURLEcho = TRUE;
  1245.         ApiReturnValue("WLRegisterURLEcho");
  1246.     }
  1247.     else
  1248.         Error(IDS_ERR_WLAPI,"WLRegisterURLEcho"); 
  1249. }
  1250.  
  1251. void CMainDlg::UnregisterURLEchoAPI()
  1252. {       
  1253.     m_staRegURLEcho = FALSE;
  1254.     m_nfyRegURLEcho.RemoveAll();
  1255.     
  1256.     if (WLUnregisterURLEcho(m_hBrowser,m_hWnd))
  1257.         ApiReturnValue("WLUnregisterURLEcho");
  1258.     else
  1259.         Error(IDS_ERR_WLAPI,"WLUnregisterURLEcho"); 
  1260. }
  1261.  
  1262. void CMainDlg::RegisterViewerAPI()
  1263. {   
  1264.     BOOL bQueryViewer = FALSE,bShellExec = FALSE,bViewDocFile = TRUE;
  1265.     char szMIME[64] = "";
  1266.     
  1267.     if (ApiDlgRegisterViewer(szMIME,sizeof(szMIME),&bQueryViewer,&bShellExec,&bViewDocFile))
  1268.     {       
  1269.         WORD wOptions = (bQueryViewer ? WL_QUERYVIEWER : 0) |
  1270.                         (bShellExec ? WL_SHELLEXECUTE : 0) |
  1271.                         (bViewDocFile ? WL_VIEWDOCFILE : 0);
  1272.         
  1273.         if (WLRegisterViewer(m_hBrowser,szMIME,wOptions,m_hWnd,WM_WEBLIB_NOTIFY))
  1274.         {
  1275.             m_staRegViewer.Add(CString(szMIME));
  1276.             ApiReturnValue("WLRegisterViewer");
  1277.         }
  1278.         else
  1279.             Error(IDS_ERR_WLAPI,"WLRegisterViewer"); 
  1280.     }
  1281. }
  1282.  
  1283. void CMainDlg::UnregisterViewerAPI()
  1284. {   
  1285.     char szMIME[64] = "";
  1286.     
  1287.     if (ApiDlgUnregisterViewer(szMIME,sizeof(szMIME)))
  1288.     {               
  1289.         RemoveFromStatusArray(m_staRegViewer,CString(szMIME));
  1290.         if (m_staRegViewer.GetSize() == 0)
  1291.             m_nfyRegViewer.RemoveAll();
  1292.             
  1293.         if (WLUnregisterViewer(m_hBrowser,szMIME,m_hWnd))
  1294.             ApiReturnValue("WLUnregisterViewer");
  1295.         else
  1296.             Error(IDS_ERR_WLAPI,"WLUnregisterViewer"); 
  1297.     }
  1298. }
  1299.  
  1300. void CMainDlg::RegisterWindowChangeAPI()
  1301. {                                               
  1302.     DWORD dwWindow = 0;
  1303.     
  1304.     if (ApiDlgRegisterWindowChange(&dwWindow))
  1305.         if (WLRegisterWindowChange(m_hBrowser,dwWindow,m_hWnd,WM_WEBLIB_NOTIFY))
  1306.         {
  1307.             m_staRegWindowChange.Add(dwWindow);
  1308.             ApiReturnValue("WLRegisterWindowChange");
  1309.         }
  1310.         else
  1311.             Error(IDS_ERR_WLAPI,"WLRegisterWindowChange"); 
  1312. }
  1313.  
  1314. void CMainDlg::UnregisterWindowChangeAPI()
  1315. {   
  1316.     DWORD dwWindow = 0;
  1317.     
  1318.     if (ApiDlgUnregisterWindowChange(&dwWindow))
  1319.     { 
  1320.         for (int nIdx=0;nIdx < m_staRegWindowChange.GetSize();nIdx++)
  1321.             if (dwWindow == m_staRegWindowChange[nIdx])
  1322.             {
  1323.                 m_staRegWindowChange.RemoveAt(nIdx);
  1324.                 break;
  1325.             }
  1326.         if (m_staRegWindowChange.GetSize() == 0)
  1327.             m_nfyRegWindowChange.RemoveAll();
  1328.             
  1329.         if (WLUnregisterWindowChange(m_hBrowser,dwWindow,m_hWnd))
  1330.             ApiReturnValue("WLUnregisterWindowChange");
  1331.         else
  1332.             Error(IDS_ERR_WLAPI,"WLUnregisterWindowChange"); 
  1333.     }
  1334. }
  1335.  
  1336. void CMainDlg::ParseAnchorAPI()
  1337. {
  1338.     char szAbsURL[128] = "",szRelURL[128] = "";
  1339.  
  1340.     if (ApiDlgParseAnchor(szAbsURL,sizeof(szAbsURL),szRelURL,sizeof(szRelURL)))
  1341.     {
  1342.         const char *pszURL = WLParseAnchor(m_hBrowser,szAbsURL,szRelURL);
  1343.         
  1344.         if (pszURL == NULL)
  1345.             Error(IDS_ERR_WLAPI,"WLParseAnchor"); 
  1346.         else
  1347.             ApiReturnValue("WLParseAnchor",pszURL);
  1348.     }
  1349. }
  1350.  
  1351. void CMainDlg::GetVersionAPI()
  1352. {   
  1353.     UINT nMajor = 0,nMinor = 0;
  1354.     
  1355.     if (ApiDlgGetVersion(&nMajor,&nMinor))
  1356.     {
  1357.         DWORD dwVersion = WLGetVersion(m_hBrowser,(WORD) nMajor,(WORD) nMinor);
  1358.         char szVersion[16];
  1359.         
  1360.         wsprintf(szVersion,"%d.%d",(int) HIWORD(dwVersion),(int) LOWORD(dwVersion));
  1361.         ApiReturnValue("WLGetVersion",szVersion);
  1362.     }
  1363. }
  1364.  
  1365. void CMainDlg::QueryURLFileAPI()
  1366. {   
  1367.     char szFile[128] = "";
  1368.     
  1369.     if (ApiDlgQueryFile(szFile,sizeof(szFile)))
  1370.     {
  1371.         const char *pszURL = WLQueryURLFile(m_hBrowser,szFile);
  1372.         
  1373.         if (pszURL == NULL)
  1374.             Error(IDS_ERR_WLAPI,"WLQueryURLFile"); 
  1375.         else
  1376.             ApiReturnValue("WLQueryURLFile",pszURL);
  1377.     }
  1378. }
  1379.  
  1380. void CMainDlg::SetNotifyMethodAPI()
  1381. {                                      
  1382.     BOOL bPost = TRUE;
  1383.     
  1384.     if (ApiDlgSetNotifyMethod(&bPost))
  1385.         if (WLSetNotifyMethod(m_hBrowser,bPost ? WL_POSTMESSAGE : WL_SENDMESSAGE))
  1386.             ApiReturnValue("WLSetNotifyMethod");
  1387.         else
  1388.             Error(IDS_ERR_WLAPI,"WLSetNotifyMethod"); 
  1389. }
  1390.  
  1391. void CMainDlg::IsToolbarActiveAPI()
  1392. {                       
  1393.     const char *pszBool = WLIsToolbarActive(m_hToolbar) ? "TRUE" : "FALSE";
  1394.     
  1395.     ApiReturnValue("WLIsToolbarActive",pszBool);    // no-op if only one toolbar
  1396. }
  1397.  
  1398. void CMainDlg::SetActiveToolbarAPI()
  1399. {
  1400.     if (WLSetActiveToolbar(m_hToolbar))
  1401.         ApiReturnValue("WLSetActiveToolbar");
  1402.     else
  1403.         Error(IDS_ERR_WLAPI,"WLSetActiveToolbar"); 
  1404. }
  1405.  
  1406. void CMainDlg::AddToolbarButtonAPI()
  1407. {       
  1408.     UINT nID = 100;
  1409.     int nIdx = 0,nBitmapStyle = 1,nBitmapMask = 0xF;
  1410.     char szText[128] = "";
  1411.         
  1412.     if (ApiDlgAddToolbarButton(&nID,&nIdx,szText,sizeof(szText),&nBitmapStyle,&nBitmapMask))
  1413.     {
  1414.         LPCSTR lpszBitmap = NULL,lpszBitmapSel = NULL;
  1415.         LPCSTR lpszBitmapFocus = NULL,lpszBitmapDisabled = NULL;
  1416.         
  1417.         if (_ISUP(nBitmapMask))
  1418.             lpszBitmap = MAKEINTRESOURCE(nBitmapStyle + APIDLG_BITMAP_UP);
  1419.         if (_ISSEL(nBitmapMask))
  1420.             lpszBitmapSel = MAKEINTRESOURCE(nBitmapStyle + APIDLG_BITMAP_SEL);
  1421.         if (_ISFOCUS(nBitmapMask))
  1422.             lpszBitmapFocus = MAKEINTRESOURCE(nBitmapStyle + APIDLG_BITMAP_FOCUS);
  1423.         if (_ISDISABLED(nBitmapMask))
  1424.             lpszBitmapDisabled = MAKEINTRESOURCE(nBitmapStyle + APIDLG_BITMAP_DISABLED);
  1425.     
  1426.         if (WLAddToolbarButton(m_hToolbar,nID,nIdx,szText,GetApiDlgDLLInstance(),
  1427.             lpszBitmap,lpszBitmapSel,lpszBitmapFocus,lpszBitmapDisabled))
  1428.         {
  1429.             m_staToolbar.Add(nID);
  1430.             ApiReturnValue("WLAddToolbarButton");
  1431.         }
  1432.         else
  1433.             Error(IDS_ERR_WLAPI,"WLAddToolbarButton"); 
  1434.     }
  1435. }
  1436.  
  1437. void CMainDlg::RemoveToolbarButtonAPI()
  1438. {   
  1439.     UINT nID = 100;
  1440.     
  1441.     if (ApiDlgRemoveToolbarButton(&nID))
  1442.     {
  1443.         for (int nIdx=0;nIdx < m_staToolbar.GetSize();nIdx++)
  1444.             if (nID == m_staToolbar[nIdx])
  1445.             {
  1446.                 m_staToolbar.RemoveAt(nIdx);
  1447.                 break;
  1448.             }
  1449.         if (m_staToolbar.GetSize() == 0)
  1450.             m_nfyToolbar.RemoveAll();
  1451.             
  1452.         if (WLRemoveToolbarButton(m_hToolbar,nID))
  1453.             ApiReturnValue("WLRemoveToolbarButton");
  1454.         else
  1455.             Error(IDS_ERR_WLAPI,"WLRemoveToolbarButton"); 
  1456.     }
  1457. }
  1458.  
  1459. void CMainDlg::IsToolbarButtonVisibleAPI()
  1460. {   
  1461.     UINT nID = 100;
  1462.     
  1463.     if (ApiDlgIsToolbarButtonVisible(&nID))                          
  1464.     {
  1465.         const char *pszBool = WLIsToolbarButtonVisible(m_hToolbar,nID) ? "TRUE" : "FALSE";
  1466.         ApiReturnValue("WLIsToolbarButtonVisible",pszBool);
  1467.     }
  1468. }
  1469.  
  1470. void CMainDlg::ShowToolbarButtonAPI()
  1471. {   
  1472.     UINT nID = 100;
  1473.     BOOL bShow = TRUE;
  1474.     
  1475.     if (ApiDlgShowToolbarButton(&nID,&bShow))
  1476.         if (WLShowToolbarButton(m_hToolbar,nID,bShow))
  1477.             ApiReturnValue("WLShowToolbarButton");
  1478.         else
  1479.             Error(IDS_ERR_WLAPI,"WLShowToolbarButton"); 
  1480. }
  1481.  
  1482. void CMainDlg::EnableToolbarButtonAPI()
  1483. {   
  1484.     UINT nID = 100;
  1485.     BOOL bEnable = TRUE;
  1486.     
  1487.     if (ApiDlgEnableToolbarButton(&nID,&bEnable))
  1488.         if (WLEnableToolbarButton(m_hToolbar,nID,bEnable))
  1489.             ApiReturnValue("WLEnableToolbarButton");
  1490.         else
  1491.             Error(IDS_ERR_WLAPI,"WLEnableToolbarButton"); 
  1492. }
  1493.  
  1494. void CMainDlg::IsToolbarButtonEnabledAPI()
  1495. {   
  1496.     UINT nID = 100;
  1497.     
  1498.     if (ApiDlgIsToolbarButtonEnabled(&nID))
  1499.     {
  1500.         const char *pszBool = WLIsToolbarButtonEnabled(m_hToolbar,nID) ? "TRUE" : "FALSE";
  1501.         ApiReturnValue("WLIsToolbarButtonEnabled",pszBool);
  1502.     }
  1503. }
  1504.  
  1505. void CMainDlg::GetToolbarTextAPI()
  1506. {   
  1507.     UINT nID = 100;
  1508.     
  1509.     if (ApiDlgGetToolbarText(&nID))
  1510.     {
  1511.         const char *pszText = WLGetToolbarText(m_hToolbar,nID == 0 ? WL_TOOLBARTEXT : nID);
  1512.         
  1513.         if (pszText == NULL)
  1514.             Error(IDS_ERR_WLAPI,"WLGetToolbarText"); 
  1515.         else
  1516.             ApiReturnValue("WLGetToolbarText",pszText);
  1517.     }
  1518. }
  1519.  
  1520. void CMainDlg::SetToolbarTextAPI()
  1521. {   
  1522.     UINT nID = 100;                      
  1523.     char szText[128] = "";
  1524.     
  1525.     if (ApiDlgSetToolbarText(&nID,szText,sizeof(szText)))
  1526.         if (WLSetToolbarText(m_hToolbar,nID == 0 ? WL_TOOLBARTEXT : nID,szText))
  1527.             ApiReturnValue("WLSetToolbarText",szText);
  1528.         else
  1529.             Error(IDS_ERR_WLAPI,"WLSetToolbarText"); 
  1530. }
  1531.  
  1532. void CMainDlg::GetToolbarFontAPI()
  1533. {                         
  1534.     BOOL bToolbar = TRUE;
  1535.     
  1536.     if (ApiDlgGetToolbarFont(&bToolbar))
  1537.     {
  1538.         HFONT hFont = WLGetToolbarFont(m_hToolbar,bToolbar ? WL_TOOLBARFONT : WL_BUTTONFONT);
  1539.         
  1540.         if (hFont == NULL)
  1541.             Error(IDS_ERR_WLAPI,"WLGetToolbarFont"); 
  1542.         else
  1543.         {   
  1544.             LOGFONT LogFont;
  1545.             ::GetObject(hFont,sizeof(LogFont),&LogFont);
  1546.             
  1547.             char szHeight[16];
  1548.             (void) _itoa((int) LogFont.lfHeight,szHeight,10);
  1549.             
  1550.             ApiReturnValue("WLGetToolbarFont",LogFont.lfFaceName,szHeight);
  1551.         }
  1552.     }
  1553. }
  1554.  
  1555. void CMainDlg::SetToolbarFontAPI()
  1556. {   
  1557.     BOOL bToolbar = TRUE;
  1558.     int nPointSize = 12; 
  1559.     char szFont[64] = "";
  1560.     
  1561.     if (ApiDlgSetToolbarFont(szFont,sizeof(szFont),&nPointSize,&bToolbar))
  1562.     {
  1563.         if (m_hFont != NULL)
  1564.         {
  1565.             ::DeleteObject(m_hFont);
  1566.             m_hFont = NULL;
  1567.         }
  1568.             
  1569.         // Get logical horizontal pixels per inch from display device.
  1570.             
  1571.         CDC *pDC = GetDC();
  1572.         ASSERT(pDC != NULL);
  1573.             
  1574.         int nLogPixelsX = pDC->GetDeviceCaps(LOGPIXELSX);        
  1575.         ReleaseDC(pDC);  
  1576.         
  1577.         // Create logical font based on user's preferences.
  1578.     
  1579.         LOGFONT Logfont;
  1580.             
  1581.         memset(&Logfont,'\0',sizeof(Logfont));
  1582.         Logfont.lfCharSet = ANSI_CHARSET;
  1583.         Logfont.lfQuality = PROOF_QUALITY;
  1584.         Logfont.lfOutPrecision = OUT_TT_ONLY_PRECIS;        
  1585.         Logfont.lfWeight = FW_NORMAL;
  1586.         Logfont.lfHeight = -((nLogPixelsX * nPointSize) / 72);
  1587.         lstrcpyn(Logfont.lfFaceName,szFont,LF_FACESIZE);
  1588.             
  1589.         if ((m_hFont = ::CreateFontIndirect(&Logfont)) == NULL)
  1590.             Error(IDS_ERR_WINAPI,"CreateFontIndirect"); 
  1591.         else
  1592.             if (WLSetToolbarFont(m_hToolbar,bToolbar ? WL_TOOLBARFONT : WL_BUTTONFONT,m_hFont))
  1593.                 ApiReturnValue("WLSetToolbarFont");
  1594.             else
  1595.                 Error(IDS_ERR_WLAPI,"WLSetToolbarFont"); 
  1596.     }
  1597. }
  1598.  
  1599. void CMainDlg::GetToolbarBkgndAPI()
  1600. {
  1601.     COLORREF crBkgnd = WLGetToolbarBkgnd(m_hToolbar); 
  1602.     RGBQUAD rgbQuad;
  1603.     char szBuf[64];
  1604.     
  1605.     memcpy(&rgbQuad,&crBkgnd,sizeof(crBkgnd));
  1606.     wsprintf(szBuf,"RGB(%d,%d,%d)",rgbQuad.rgbBlue,rgbQuad.rgbGreen,rgbQuad.rgbRed);
  1607.     ApiReturnValue("WLGetToolbarBkgnd",szBuf);
  1608. }
  1609.  
  1610. void CMainDlg::SetToolbarBkgndAPI()
  1611. {
  1612.     int nRed = 0,nGreen = 0,nBlue = 0;
  1613.  
  1614.     if (ApiDlgSetToolbarBkgnd(&nRed,&nGreen,&nBlue))
  1615.         if (WLSetToolbarBkgnd(m_hToolbar,RGB(nRed,nGreen,nBlue)))
  1616.             ApiReturnValue("WLSetToolbarBkgnd");
  1617.         else
  1618.             Error(IDS_ERR_WLAPI,"WLSetToolbarBkgnd"); 
  1619. }
  1620.  
  1621. void CMainDlg::GetToolbarTextColorAPI()
  1622. {   
  1623.     BOOL bToolbar = TRUE;
  1624.     
  1625.     if (ApiDlgGetToolbarTextColor(&bToolbar))
  1626.     {
  1627.         COLORREF crBkgnd = WLGetToolbarTextColor(m_hToolbar,
  1628.             bToolbar ? WL_TOOLBARTEXTCOLOR : WL_BUTTONTEXTCOLOR);
  1629.         RGBQUAD rgbQuad;
  1630.         char szBuf[64];
  1631.         
  1632.         memcpy(&rgbQuad,&crBkgnd,sizeof(crBkgnd));
  1633.         wsprintf(szBuf,"RGB(%d,%d,%d)",rgbQuad.rgbBlue,rgbQuad.rgbGreen,rgbQuad.rgbRed);
  1634.         ApiReturnValue("WLGetToolbarTextColor",szBuf);
  1635.     }
  1636. }
  1637.  
  1638. void CMainDlg::SetToolbarTextColorAPI()
  1639. {   
  1640.     BOOL bToolbar = TRUE;
  1641.     int nRed = 0,nGreen = 0,nBlue = 0;
  1642.     
  1643.     if (ApiDlgSetToolbarTextColor(&nRed,&nGreen,&nBlue,&bToolbar)) 
  1644.         if (WLSetToolbarTextColor(m_hToolbar,
  1645.             bToolbar ? WL_TOOLBARTEXTCOLOR : WL_BUTTONTEXTCOLOR,
  1646.             RGB(nRed,nGreen,nBlue)))
  1647.             ApiReturnValue("WLSetToolbarTextColor");
  1648.         else
  1649.             Error(IDS_ERR_WLAPI,"WLSetToolbarTextColor"); 
  1650. }
  1651.  
  1652. void CMainDlg::HtmlEnumParseTreeAPI()
  1653. {
  1654.     m_nfyEnumParseTree.RemoveAll();
  1655.     
  1656.     if (WLHtmlEnumParseTree(m_hParse,m_hWnd,WM_WEBLIB_ENUMPARSETREE))
  1657.         ApiReturnValue("WLHtmlEnumParseTree");
  1658.     else
  1659.         Error(IDS_ERR_WLAPI,"WLHtmlEnumParseTree"); 
  1660. }
  1661.  
  1662. void CMainDlg::HtmlGetChildAPI()
  1663. {   
  1664.     HELEMENT hElement = WLHtmlGetChild(m_hParse,m_hElement);
  1665.     
  1666.     if (hElement == NULL)                               
  1667.         Error(IDS_ERR_WLAPI,"WLHtmlGetChild"); 
  1668.     else
  1669.     {
  1670.         ApiReturnValue("WLHtmlGetChild");
  1671.         m_hElement = hElement;
  1672.         m_hTagAttr = NULL;
  1673.     }
  1674. }
  1675.  
  1676. void CMainDlg::HtmlGetParentAPI()
  1677. {   
  1678.     HELEMENT hElement = WLHtmlGetParent(m_hParse,m_hElement);
  1679.     
  1680.     if (hElement == NULL)                               
  1681.         Error(IDS_ERR_WLAPI,"WLHtmlGetParent"); 
  1682.     else
  1683.     {
  1684.         ApiReturnValue("WLHtmlGetParent");
  1685.         m_hElement = hElement;
  1686.         m_hTagAttr = NULL;
  1687.     }
  1688. }
  1689.  
  1690. void CMainDlg::HtmlGetSiblingAPI()
  1691. {
  1692.     UINT nRel = WL_FIRSTELEM;
  1693.     
  1694.     if (ApiDlgHtmlGetSibling(&nRel))
  1695.     {
  1696.         HELEMENT hElement = WLHtmlGetSibling(m_hParse,m_hElement,nRel);
  1697.         
  1698.         if (hElement == NULL)                               
  1699.             Error(IDS_ERR_WLAPI,"WLHtmlGetSibling"); 
  1700.         else
  1701.         {
  1702.             ApiReturnValue("WLHtmlGetSibling");
  1703.             m_hElement = hElement;
  1704.             m_hTagAttr = NULL;
  1705.         }
  1706.     }
  1707. }
  1708.  
  1709. void CMainDlg::HtmlGetElementTypeAPI()
  1710. {       
  1711.     const char *pszType = "?";
  1712.     
  1713.     switch (WLHtmlGetElementType(m_hParse,m_hElement))
  1714.     {
  1715.         case WL_ROOT:
  1716.             pszType = "ROOT";
  1717.             break;
  1718.             
  1719.         case WL_TAG:
  1720.             pszType = "TAG";
  1721.             break;
  1722.             
  1723.         case WL_SPECIALCHAR:
  1724.             pszType = "SPECIAL-CHAR";
  1725.             break;
  1726.             
  1727.         case WL_COMMENT:
  1728.             pszType = "COMMENT";
  1729.             break;
  1730.             
  1731.         case WL_TEXT:
  1732.             pszType = "TEXT";
  1733.             break;
  1734.     }       
  1735.     ApiReturnValue("WLHtmlGetElementType",pszType);
  1736. }
  1737.  
  1738. void CMainDlg::HtmlGetElementTextAPI()
  1739. {
  1740.     const char *pszText = WLHtmlGetElementText(m_hParse,m_hElement);
  1741.     
  1742.     ApiReturnValue("WLHtmlGetElementText",pszText == NULL ? "" : pszText);
  1743. }
  1744.  
  1745. void CMainDlg::HtmlGetTextAttrAPI()
  1746. {   
  1747.     if (WLHtmlGetElementType(m_hParse,m_hElement) == WL_TEXT)
  1748.     {
  1749.         DWORD dwAttr = WLHtmlGetTextAttr(m_hParse,m_hElement);
  1750.         char szAttr[16] = "0x";
  1751.         
  1752.         _ltoa((long) dwAttr,&szAttr[2],16);
  1753.         ApiReturnValue("WLHtmlGetTextAttr",szAttr);
  1754.     }
  1755.     else 
  1756.         Error(IDS_ERR_NOTTEXT); 
  1757. }
  1758.  
  1759. void CMainDlg::HtmlGetTagNameAPI()
  1760. {   
  1761.     if (WLHtmlGetElementType(m_hParse,m_hElement) == WL_TAG)
  1762.     {
  1763.         const char *pszTag = WLHtmlGetTagName(m_hParse,m_hElement);
  1764.         ApiReturnValue("WLHtmlGetTagName",pszTag);
  1765.     }
  1766.     else
  1767.         Error(IDS_ERR_NOTTAG); 
  1768. }
  1769.  
  1770. void CMainDlg::HtmlGetTagTypeAPI()
  1771. {   
  1772.     if (WLHtmlGetElementType(m_hParse,m_hElement) == WL_TAG)
  1773.     {
  1774.         UINT nType = WLHtmlGetTagType(m_hParse,m_hElement);
  1775.         char szType[16];
  1776.         
  1777.         _itoa((int) nType,szType,10);
  1778.         ApiReturnValue("WLHtmlGetTagType",szType);
  1779.     }
  1780.     else
  1781.         Error(IDS_ERR_NOTTAG); 
  1782. }
  1783.  
  1784. void CMainDlg::HtmlGetTagAttrAPI()
  1785. {   
  1786.     WORD wType = 0;
  1787.     char szAttr[128] = "",szValue[128] = "";
  1788.     
  1789.     if (m_hTagAttr = WLHtmlGetTagAttr(m_hParse,m_hElement,m_hTagAttr,
  1790.         &wType,szAttr,sizeof(szAttr),szValue,sizeof(szValue)))
  1791.         ApiReturnValue("WLHtmlGetTagAttr",szValue,szAttr);
  1792.     else
  1793.         Error(IDS_ERR_WLAPI,"WLHtmlGetTagAttr"); 
  1794. }
  1795.  
  1796. void CMainDlg::HtmlExtractTagAttrAPI()
  1797. {
  1798.     char szAttr[64] = "";
  1799.     
  1800.     if (ApiDlgHtmlExtractTagAttr(szAttr,sizeof(szAttr)))                               
  1801.     {
  1802.         const char *pszValue = WLHtmlExtractTagAttr(m_hParse,m_hElement,szAttr);
  1803.         
  1804.         if (pszValue == NULL)
  1805.             Error(IDS_ERR_WLAPI,"WLHtmlExtractTagAttr"); 
  1806.         else
  1807.             ApiReturnValue("WLHtmlExtractTagAttr",pszValue);
  1808.     }
  1809. }
  1810.  
  1811. void CMainDlg::HtmlFindTextAPI()
  1812. {   
  1813.     char szText[128] = "";
  1814.     
  1815.     if (ApiDlgHtmlFindText(szText,sizeof(szText))) 
  1816.     {
  1817.         HELEMENT hElement = WLHtmlFindText(m_hParse,m_hElement,szText);
  1818.         
  1819.         if (hElement == NULL)                               
  1820.             Error(IDS_ERR_WLAPI,"WLHtmlFindText"); 
  1821.         else
  1822.         {
  1823.             ApiReturnValue("WLHtmlFindText");
  1824.             m_hElement = hElement;
  1825.             m_hTagAttr = NULL;
  1826.         }
  1827.     }
  1828. }
  1829.  
  1830. void CMainDlg::HtmlFindSpecialAPI()
  1831. {   
  1832.     char szSpecial[128] = "";
  1833.     
  1834.     if (ApiDlgHtmlFindSpecial(szSpecial,sizeof(szSpecial)))
  1835.     {
  1836.         HELEMENT hElement = WLHtmlFindSpecial(m_hParse,m_hElement,szSpecial);
  1837.         
  1838.         if (hElement == NULL)                               
  1839.             Error(IDS_ERR_WLAPI,"WLHtmlFindSpecial"); 
  1840.         else
  1841.         {
  1842.             ApiReturnValue("WLHtmlFindSpecial");
  1843.             m_hElement = hElement;
  1844.             m_hTagAttr = NULL;
  1845.         }
  1846.     }
  1847. }
  1848.  
  1849. void CMainDlg::HtmlFindCommentAPI()
  1850. {   
  1851.     char szComment[128] = "";
  1852.     
  1853.     if (ApiDlgHtmlFindComment(szComment,sizeof(szComment)))
  1854.     {   
  1855.         HELEMENT hElement = WLHtmlFindComment(m_hParse,m_hElement,szComment);
  1856.         
  1857.         if (hElement == NULL)                               
  1858.             Error(IDS_ERR_WLAPI,"WLHtmlFindComment"); 
  1859.         else
  1860.         {
  1861.             ApiReturnValue("WLHtmlFindComment");
  1862.             m_hElement = hElement;
  1863.             m_hTagAttr = NULL;
  1864.         }
  1865.     }
  1866. }
  1867.  
  1868. void CMainDlg::HtmlFindTagTypeAPI()
  1869. {   
  1870.     UINT nTag = HTML_BASE;
  1871.     
  1872.     if (ApiDlgHtmlFindTagType(&nTag))
  1873.     {   
  1874.         HELEMENT hElement = WLHtmlFindTagType(m_hParse,m_hElement,nTag);
  1875.         
  1876.         if (hElement == NULL)                               
  1877.             Error(IDS_ERR_WLAPI,"WLHtmlFindTagType"); 
  1878.         else
  1879.         {
  1880.             ApiReturnValue("WLHtmlFindTagType");
  1881.             m_hElement = hElement;
  1882.             m_hTagAttr = NULL;
  1883.         }
  1884.     }
  1885. }
  1886.  
  1887. void CMainDlg::HtmlFindTagNameAPI()
  1888. {   
  1889.     char szTag[64] = "";
  1890.     
  1891.     if (ApiDlgHtmlFindTagName(szTag,sizeof(szTag)))
  1892.     {   
  1893.         HELEMENT hElement = WLHtmlFindTagName(m_hParse,m_hElement,szTag);
  1894.         
  1895.         if (hElement == NULL)                               
  1896.             Error(IDS_ERR_WLAPI,"WLHtmlFindTagName"); 
  1897.         else
  1898.         {
  1899.             ApiReturnValue("WLHtmlFindTagName");
  1900.             m_hElement = hElement;
  1901.             m_hTagAttr = NULL;
  1902.         }
  1903.     }
  1904. }
  1905.  
  1906. void CMainDlg::HtmlFindTagAttrAPI()
  1907. {   
  1908.     UINT nTag = HTML_BASE;    
  1909.     char szAttr[64] = "",szValue[64] = "";
  1910.         
  1911.     if (ApiDlgHtmlFindTagAttr(szAttr,sizeof(szAttr),szValue,sizeof(szValue),&nTag))
  1912.     {
  1913.         HELEMENT hElement = WLHtmlFindTagAttr(m_hParse,m_hElement,nTag,szAttr,szValue);
  1914.         
  1915.         if (hElement == NULL)                               
  1916.             Error(IDS_ERR_WLAPI,"WLHtmlFindTagAttr"); 
  1917.         else
  1918.         {
  1919.             ApiReturnValue("WLHtmlFindTagAttr");
  1920.             m_hElement = hElement;
  1921.             m_hTagAttr = NULL;
  1922.         }
  1923.     }
  1924. }
  1925.  
  1926. void CMainDlg::HtmlEnumFindTextAPI()
  1927. {
  1928.     char szText[128] = ""; 
  1929.     
  1930.     if (ApiDlgHtmlEnumFindText(szText,sizeof(szText)))
  1931.     {
  1932.         m_nfyEnumFindText.RemoveAll();
  1933.         
  1934.         if (WLHtmlEnumFindText(m_hParse,m_hElement,szText,m_hWnd,WM_WEBLIB_ENUMFINDTEXT))
  1935.             ApiReturnValue("WLHtmlEnumFindText");
  1936.         else
  1937.             Error(IDS_ERR_WLAPI,"WLHtmlEnumFindText"); 
  1938.     }
  1939. }
  1940.  
  1941. void CMainDlg::HtmlEnumFindSpecialAPI()
  1942. {
  1943.     char szSpecial[128] = "";
  1944.     
  1945.     if (ApiDlgHtmlEnumFindSpecial(szSpecial,sizeof(szSpecial)))
  1946.     {
  1947.         m_nfyEnumFindSpecial.RemoveAll();
  1948.         
  1949.         if (WLHtmlEnumFindSpecial(m_hParse,m_hElement,szSpecial,m_hWnd,WM_WEBLIB_ENUMFINDSPEC))
  1950.             ApiReturnValue("WLHtmlEnumFindSpecial");
  1951.         else
  1952.             Error(IDS_ERR_WLAPI,"WLHtmlEnumFindSpecial"); 
  1953.     }
  1954. }
  1955.  
  1956. void CMainDlg::HtmlEnumFindCommentAPI()
  1957. {
  1958.     char szComment[128] = "";
  1959.     
  1960.     if (ApiDlgHtmlEnumFindComment(szComment,sizeof(szComment)))
  1961.     {
  1962.         m_nfyEnumFindComment.RemoveAll();
  1963.         
  1964.         if (WLHtmlEnumFindComment(m_hParse,m_hElement,szComment,m_hWnd,WM_WEBLIB_ENUMFINDCOMM))
  1965.             ApiReturnValue("WLHtmlEnumFindComment");
  1966.         else
  1967.             Error(IDS_ERR_WLAPI,"WLHtmlEnumFindComment"); 
  1968.     }
  1969. }
  1970.  
  1971. void CMainDlg::HtmlEnumFindTagTypeAPI()
  1972. {
  1973.     UINT nTag = HTML_BASE;
  1974.     
  1975.     if (ApiDlgHtmlEnumFindTagType(&nTag))
  1976.     {
  1977.         m_nfyEnumFindTagType.RemoveAll();
  1978.         
  1979.         if (WLHtmlEnumFindTagType(m_hParse,m_hElement,nTag,m_hWnd,WM_WEBLIB_ENUMFINDTAGTYPE))
  1980.             ApiReturnValue("WLHtmlEnumFindTagType");
  1981.         else
  1982.             Error(IDS_ERR_WLAPI,"WLHtmlEnumFindTagType"); 
  1983.     }
  1984. }
  1985.  
  1986. void CMainDlg::HtmlEnumFindTagNameAPI()
  1987. {
  1988.     char szTag[64] = "";
  1989.     
  1990.     if (ApiDlgHtmlEnumFindTagName(szTag,sizeof(szTag)))
  1991.     {
  1992.         m_nfyEnumFindTagName.RemoveAll();
  1993.         
  1994.          if (WLHtmlEnumFindTagName(m_hParse,m_hElement,szTag,m_hWnd,WM_WEBLIB_ENUMFINDTAGNAME))
  1995.              ApiReturnValue("WLHtmlEnumFindTagName");
  1996.         else
  1997.             Error(IDS_ERR_WLAPI,"WLHtmlEnumFindTagName"); 
  1998.     }
  1999. }
  2000.  
  2001. void CMainDlg::HtmlEnumFindTagAttrAPI()
  2002. {   
  2003.     UINT nTag = HTML_BASE;    
  2004.     char szAttr[64] = "",szValue[64] = "";
  2005.         
  2006.     if (ApiDlgHtmlEnumFindTagAttr(szAttr,sizeof(szAttr),szValue,sizeof(szValue),&nTag))
  2007.     {
  2008.         m_nfyEnumFindTagAttr.RemoveAll();
  2009.         
  2010.         if (WLHtmlEnumFindTagAttr(m_hParse,m_hElement,nTag,szAttr,szValue,m_hWnd,WM_WEBLIB_ENUMFINDTAGATTR))
  2011.             ApiReturnValue("WLHtmlEnumFindTagAttr");
  2012.         else
  2013.             Error(IDS_ERR_WLAPI,"WLHtmlEnumFindTagAttr"); 
  2014.     }
  2015. }
  2016.  
  2017. void CMainDlg::AppendFormDataAPI()
  2018. {   
  2019.     char szData[MAX_FORMDATA] = "",szName[64] = "";
  2020.     
  2021.     if (ApiDlgAppendFormData(szData,sizeof(szData),szName,sizeof(szName)))
  2022.     {
  2023.         m_hFormData = WLAppendFormData(m_hFormData,szName,szData,lstrlen(szData) + 1);
  2024.         
  2025.         if (m_hFormData == NULL)
  2026.             Error(IDS_ERR_WLAPI,"WLAppendFormData"); 
  2027.         else
  2028.         {
  2029.             OnUtilAPI();
  2030.             ApiReturnValue("WLAppendFormData");
  2031.         }
  2032.     }
  2033. }
  2034.  
  2035. void CMainDlg::GetFormDataLengthAPI()
  2036. {
  2037.     UINT nLength = WLGetFormDataLength(m_hFormData);
  2038.     char szLength[16];
  2039.     
  2040.     ApiReturnValue("WLGetFormDataLength",_itoa((int) nLength,szLength,10));
  2041. }
  2042.  
  2043. void CMainDlg::ParseAbsoluteURLAPI()
  2044. {                          
  2045.     char szURL[128] = "";
  2046.     
  2047.     if (ApiDlgParseAbsoluteURL(szURL,sizeof(szURL)))
  2048.     {
  2049.         char szProtocol[32] = "",szHost[64] = "",szPath[128] = "";
  2050.         UINT nPort = 0;
  2051.     
  2052.         if (WLParseAbsoluteURL(szURL,szProtocol,sizeof(szProtocol),szHost,sizeof(szHost),
  2053.             &nPort,szPath,sizeof(szPath)))
  2054.         {
  2055.             char szBuf[256];
  2056.             
  2057.             wsprintf(szBuf,"%s %s %d %s",szProtocol,szHost,nPort,szPath);
  2058.             ApiReturnValue("WLParseAbsoluteURL",szBuf);
  2059.         }
  2060.         else
  2061.               Error(IDS_ERR_WLAPI,"WLParseAbsoluteURL");
  2062.     }
  2063. }
  2064.  
  2065. ///////////////////////////////////////////////////////////////////////////// 
  2066. // Message handler for API notifications.
  2067.  
  2068. LONG CMainDlg::OnApiNotification(UINT wParam,LONG lParam)
  2069. {
  2070.     CStringArray *pnfyArray = m_pnfyArray;    
  2071.     char szMessage[512];
  2072.     
  2073.     switch (wParam)
  2074.     {
  2075.         case WLN_BEGINPROGRESS: 
  2076.         { 
  2077.             DWORD dwTrx = WLNGetTransaction(lParam);
  2078.             const char *pszProgress = WLNGetProgressString(lParam);
  2079.             
  2080.             wsprintf(szMessage,"BEGINPROGRESS: %ld %s",dwTrx,pszProgress);
  2081.             break;
  2082.         }
  2083.         
  2084.         case WLN_SETPROGRESSRANGE:      
  2085.         {   
  2086.             DWORD dwTrx = WLNGetTransaction(lParam);
  2087.             DWORD dwMaximum = WLNGetProgressMaximum(lParam);
  2088.             
  2089.             wsprintf(szMessage,"SETPROGRESSRANGE: %ld %ld",dwTrx,dwMaximum);
  2090.             break;
  2091.         }        
  2092.             
  2093.         case WLN_MAKINGPROGRESS:      
  2094.         {   
  2095.             DWORD dwTrx = WLNGetTransaction(lParam);
  2096.             DWORD dwProgress = WLNGetProgressValue(lParam);
  2097.             const char *pszProgress = WLNGetProgressString(lParam);
  2098.             
  2099.             wsprintf(szMessage,"MAKINGPROGRESS: %ld %ld %s",dwTrx,dwProgress,pszProgress);
  2100.             break;
  2101.         }
  2102.         
  2103.         case WLN_ENDPROGRESS:      
  2104.         {   
  2105.             DWORD dwTrx = WLNGetTransaction(lParam);
  2106.             
  2107.             wsprintf(szMessage,"ENDPROGRESS: %ld",dwTrx);
  2108.             break;
  2109.         }
  2110.         
  2111.         case WLN_FINISHED:      
  2112.         {   
  2113.             DWORD dwTrx = WLNGetTransaction(lParam);
  2114.             DWORD dwWindow = WLNGetWindow(lParam);
  2115.             
  2116.             wsprintf(szMessage,"FINISHED: %ld %ld",dwTrx,dwWindow);
  2117.             break;
  2118.         }
  2119.         
  2120.         case WLN_CANCELED:      
  2121.         {   
  2122.             DWORD dwTrx = WLNGetTransaction(lParam);
  2123.             
  2124.             wsprintf(szMessage,"CANCELED: %ld",dwTrx);
  2125.             break;
  2126.         }            
  2127.         
  2128.         case WLN_URLECHO:
  2129.         {   
  2130.             DWORD dwWindow = WLNGetWindow(lParam);
  2131.             const char *pszURL = WLNGetURL(lParam);
  2132.             const char *pszMIME = WLNGetMIMEType(lParam);
  2133.             const char *pszRef = WLNGetReferrer(lParam);
  2134.             
  2135.             wsprintf(szMessage,"URLECHO: %ld %s %s %s",dwWindow,pszURL,pszMIME,pszRef);
  2136.             pnfyArray = &m_nfyRegURLEcho;
  2137.             break;
  2138.         }
  2139.         
  2140.         case WLN_OPENURL:
  2141.         {   
  2142.             DWORD dwWindow = WLNGetWindow(lParam);
  2143.             DWORD dwTrx = WLNGetTransaction(lParam);
  2144.             DWORD dwFlags = WLNGetFlags(lParam);
  2145.             const char *pszURL = WLNGetURL(lParam);
  2146.             const char *pszMIME = WLNGetMIMEType(lParam);
  2147.             const char *pszSaveFile = WLNGetSaveFile(lParam);
  2148.             const char *pszFormData = WLNGetFormData(lParam);
  2149.             
  2150.             wsprintf(szMessage,
  2151.                 "OPENURL: WIN=%ld TX=%ld FL=%ld URL=%s MIME=%s FILE=%s FMDATA=%s",
  2152.                 dwWindow,dwTrx,dwFlags,pszURL,pszMIME,pszSaveFile,pszFormData);
  2153.             pnfyArray = &m_nfyRegProtocol;
  2154.             break;
  2155.         }
  2156.         
  2157.         case WLN_WINDOWCHANGE:
  2158.         {   
  2159.             DWORD dwWindow = WLNGetWindow(lParam);
  2160.             DWORD dwFlags = WLNGetFlags(lParam);
  2161.             DWORD dwX = WLNGetX(lParam);
  2162.             DWORD dwY = WLNGetY(lParam);
  2163.             DWORD dwWidth = WLNGetWidth(lParam);
  2164.             DWORD dwHeight = WLNGetHeight(lParam);
  2165.             
  2166.             wsprintf(szMessage,"WINDOWCHANGE: WIN=%ld FL=%ld X=%ld Y=%ld CX=%ld CY=%ld",
  2167.                 dwWindow,dwFlags,dwX,dwY,dwWidth,dwHeight);
  2168.             pnfyArray = &m_nfyRegWindowChange;
  2169.             break;
  2170.         }
  2171.         
  2172.         case WLN_QUERYVIEWER:
  2173.         {   
  2174.             const char *pszURL = WLNGetURL(lParam);
  2175.             const char *pszMIME = WLNGetMIMEType(lParam); 
  2176.             char szFile[128];
  2177.             
  2178.             wsprintf(szMessage,"QUERYVIEWER: %s %s",pszURL,pszMIME);
  2179.             pnfyArray = &m_nfyRegViewer;
  2180.             
  2181.             wsprintf(szFile,"C:\\TEMP\\%lx.HTM",::GetTickCount());
  2182.             WLNSetFileName(lParam,szFile);            // return filename to browser
  2183.             break;
  2184.         }
  2185.         
  2186.         case WLN_VIEWDOCFILE:
  2187.         {
  2188.             const char *pszURL = WLNGetURL(lParam);
  2189.             const char *pszMIME = WLNGetMIMEType(lParam);
  2190.             const char *pszFile = WLNGetFileName(lParam);
  2191.             DWORD dwWindow = WLNGetWindow(lParam);
  2192.             
  2193.             wsprintf(szMessage,"VIEWDOCFILE: %s %s %s %ld",pszURL,pszMIME,pszFile,dwWindow);
  2194.             pnfyArray = &m_nfyRegViewer;
  2195.             break;
  2196.         }
  2197.         
  2198.         case WLN_BUTTONCLICKED:
  2199.         {                                                                                    
  2200.             UINT nButtonID = WLNGetButtonID(lParam);
  2201.             
  2202.             wsprintf(szMessage,"BUTTONCLICKED: %u",nButtonID);
  2203.             pnfyArray = &m_nfyToolbar;
  2204.             break;
  2205.         }
  2206.         
  2207.         case WLN_BROWSERSTART:
  2208.         {   
  2209.             lstrcpy(szMessage,"BROWSERSTART");
  2210.             pnfyArray = NULL;                        // recorded only to log
  2211.             break;
  2212.         }
  2213.         
  2214.         case WLN_BROWSEREXIT:
  2215.         {   
  2216.             lstrcpy(szMessage,"BROWSEREXIT");
  2217.             pnfyArray = NULL;                        // recorded only to log
  2218.             break;
  2219.         }        
  2220.     }
  2221.     
  2222.     if (pnfyArray != NULL)
  2223.         pnfyArray->Add(CString(szMessage));
  2224.     
  2225.     if (m_bLogging)
  2226.     {
  2227.         ofstream outfile(m_strLogFile,ios::out | ios::app);
  2228.         
  2229.         if (outfile.is_open() && outfile.good())
  2230.         {                   
  2231.             outfile << "NFY --> " << szMessage << endl;
  2232.             outfile.close();
  2233.         }
  2234.     }
  2235.     return 0;
  2236. }
  2237.  
  2238. ///////////////////////////////////////////////////////////////////////////// 
  2239. //  Message handler for HTML parsing notifications.
  2240.  
  2241. LONG CMainDlg::OnEnumParseTree(UINT wParam,LONG lParam)
  2242. {
  2243.     EnumHtmlElement(m_nfyEnumParseTree,"ENUMTREE",wParam,lParam);               
  2244.     return TRUE;                        // return TRUE to continue enumeration
  2245. }
  2246.  
  2247. LONG CMainDlg::OnEnumFindText(UINT wParam,LONG lParam)
  2248. {   
  2249.     EnumHtmlElement(m_nfyEnumFindText,"ENUMTEXT",wParam,lParam);    
  2250.     return TRUE;
  2251. }
  2252.  
  2253. LONG CMainDlg::OnEnumFindSpecial(UINT wParam,LONG lParam)
  2254. {   
  2255.     EnumHtmlElement(m_nfyEnumFindSpecial,"ENUMSPEC",wParam,lParam);    
  2256.     return TRUE;
  2257. }
  2258.  
  2259. LONG CMainDlg::OnEnumFindComment(UINT wParam,LONG lParam)
  2260. {   
  2261.     EnumHtmlElement(m_nfyEnumFindComment,"ENUMCOMM",wParam,lParam);    
  2262.     return TRUE;
  2263. }
  2264.  
  2265. LONG CMainDlg::OnEnumFindTagType(UINT wParam,LONG lParam)
  2266. {   
  2267.     EnumHtmlElement(m_nfyEnumFindTagType,"ENUMTYPE",wParam,lParam);    
  2268.     return TRUE;
  2269. }
  2270.  
  2271. LONG CMainDlg::OnEnumFindTagName(UINT wParam,LONG lParam)
  2272. {   
  2273.     EnumHtmlElement(m_nfyEnumFindTagName,"ENUMTAG",wParam,lParam);    
  2274.     return TRUE;
  2275. }
  2276.  
  2277. LONG CMainDlg::OnEnumFindTagAttr(UINT wParam,LONG lParam)
  2278. {   
  2279.     EnumHtmlElement(m_nfyEnumFindTagAttr,"ENUMATTR",wParam,lParam);    
  2280.     return TRUE;
  2281. }
  2282.  
  2283. ///////////////////////////////////////////////////////////////////////////// 
  2284. // Handler for message sent by DLL when dialog is destroyed, We enable our
  2285. // window so we become active window after DLL dialog dies.
  2286.  
  2287. LONG CMainDlg::OnApiDlgDestroy(UINT wParam,LONG lParam)
  2288. {
  2289.     EnableWindow(TRUE); 
  2290.     return 0;
  2291. }
  2292.  
  2293. ///////////////////////////////////////////////////////////////////////////// 
  2294. // Methods to display API results in prompt line (also performs logging).
  2295.  
  2296. void CMainDlg::ApiReturnValue(const char *pszAPI,const char *pszParm1,const char *pszParm2)
  2297. {                                     
  2298.     CString strMsg = pszAPI;
  2299.     
  2300.     if (pszParm1 == NULL)
  2301.     {   
  2302.         CString strSuccess;
  2303.         strSuccess.LoadString(IDS_PROMPT_SUCCESS);
  2304.         
  2305.         strMsg += ": ";
  2306.         strMsg += strSuccess;
  2307.     }
  2308.     else
  2309.     {
  2310.         strMsg += ": [";
  2311.         strMsg += pszParm1;
  2312.         strMsg += "]";
  2313.         
  2314.         if (pszParm2 != NULL)     
  2315.         {
  2316.             strMsg += " [";
  2317.             strMsg += pszParm2;
  2318.             strMsg += "]";
  2319.         }
  2320.     }
  2321.     GetDlgItem(IDC_PROMPT)->SetWindowText(strMsg);
  2322.     
  2323.     if (m_bLogging)
  2324.     {
  2325.         ofstream outfile(m_strLogFile,ios::out | ios::app);
  2326.         
  2327.         if (outfile.is_open() && outfile.good())
  2328.         {                   
  2329.             outfile << "API --> " << strMsg << endl;
  2330.             outfile.close();
  2331.         }
  2332.     }
  2333. }
  2334.  
  2335. void CMainDlg::Error(UINT nMsgID,const char *pszParm)
  2336. {
  2337.     CString strMsg;
  2338.     strMsg.LoadString(nMsgID);
  2339.     
  2340.     if (pszParm != NULL)
  2341.         strMsg += pszParm;
  2342.     GetDlgItem(IDC_PROMPT)->SetWindowText(strMsg);
  2343.     
  2344.     if (m_bLogging)
  2345.     {
  2346.         ofstream outfile(m_strLogFile,ios::out | ios::app);
  2347.         
  2348.         if (outfile.is_open() && outfile.good())
  2349.         {                   
  2350.             outfile << "ERROR --> " << strMsg << endl;
  2351.             outfile.close();
  2352.         }
  2353.     }
  2354. }
  2355.  
  2356. ///////////////////////////////////////////////////////////////////////////// 
  2357. // Method to format info about HTML element in string (and also to log file).
  2358.  
  2359. void CMainDlg::EnumHtmlElement(CStringArray &nfyArray,const char *pszEnum,
  2360.     UINT wParam,LONG lParam)
  2361. {               
  2362.     HELEMENT hElement = (HELEMENT) lParam;
  2363.     char szMessage[256];
  2364.     
  2365.     switch (wParam)
  2366.     {
  2367.         case WL_ROOT:   
  2368.             wsprintf(szMessage,"ROOT");
  2369.             break;
  2370.             
  2371.         case WL_TEXT:
  2372.             wsprintf(szMessage,"TEXT: %.240s %ld",
  2373.                 WLHtmlGetElementText(m_hParse,hElement),
  2374.                 WLHtmlGetTextAttr(m_hParse,hElement));
  2375.             break;
  2376.             
  2377.         case WL_TAG:
  2378.             wsprintf(szMessage,"TAG: %s %d",
  2379.                 WLHtmlGetTagName(m_hParse,hElement),
  2380.                 WLHtmlGetTagType(m_hParse,hElement));
  2381.             break;
  2382.             
  2383.         case WL_SPECIALCHAR:
  2384.             wsprintf(szMessage,"SPECIALCHAR: %s",
  2385.                 WLHtmlGetElementText(m_hParse,hElement));
  2386.             break;
  2387.             
  2388.         case WL_COMMENT:
  2389.             wsprintf(szMessage,"COMMENT: %.240s",
  2390.                 WLHtmlGetElementText(m_hParse,hElement));
  2391.             break;
  2392.             
  2393.         default:
  2394.             lstrcpy(szMessage,"???");
  2395.     }
  2396.     
  2397.     nfyArray.Add(CString(szMessage));
  2398.     
  2399.     if (m_bLogging)
  2400.     {
  2401.         ofstream outfile(m_strLogFile,ios::out | ios::app);
  2402.         
  2403.         if (outfile.is_open() && outfile.good())
  2404.         {                   
  2405.             outfile << pszEnum << " --> " << szMessage << endl;
  2406.             outfile.close();
  2407.         }
  2408.     }       
  2409. }
  2410.  
  2411. ///////////////////////////////////////////////////////////////////////////// 
  2412. // Fill info listbox with strings from string array.
  2413.  
  2414. void CMainDlg::FillInfoListbox(CStringArray &nfyArray)
  2415. {
  2416.     m_ListboxInfo.ResetContent();
  2417.     for (int nIdx=0;nIdx < nfyArray.GetSize();nIdx++)
  2418.         m_ListboxInfo.AddString(nfyArray.GetAt(nIdx));
  2419. }
  2420.  
  2421. ///////////////////////////////////////////////////////////////////////////// 
  2422. // Find string in status string array and remove it.
  2423.  
  2424. void CMainDlg::RemoveFromStatusArray(CStringArray &staArray,CString &strItem)
  2425. {
  2426.     for (int nIdx=0;nIdx < staArray.GetSize();nIdx++)
  2427.         if (strItem == staArray[nIdx])
  2428.         {
  2429.             staArray.RemoveAt(nIdx);
  2430.             break;
  2431.         }
  2432. }
  2433.  
  2434.